eimxml 0.0.2 → 0.0.3.1

data/spec/formatter_spec.rb

@@ -0,0 +1,260 @@
+require "eim_xml/formatter"
+require "eim_xml/dsl"
+
+describe EimXML::Formatter do
+	describe ".write" do
+		it "should return output object" do
+			s = ""
+			EimXML::Formatter.write(EimXML::Element.new(:e), :out=>s).should be_equal(s)
+		end
+
+		it "should return string when destination not given" do
+			r = EimXML::Formatter.write(EimXML::Element.new(:e))
+			r.should be_kind_of(String)
+		end
+
+		describe "should return formatted elements string" do
+			def write(*arg)
+				EimXML::Formatter.write(*arg)
+			end
+
+			it "(element not have content)"do
+				write(EimXML::DSL.element(:e)).should == "<e />\n"
+			end
+
+			it "(empty element which has attributes)" do
+				r = (write(EimXML::DSL.element(:e, :a1=>"v1", :a2=>"v2")) =~ %r[<e (a.='v.') (a.='v.') />])
+				r.should_not be_nil
+				[$1, $2].sort.should == ["a1='v1'", "a2='v2'"]
+			end
+
+			it "(element in element)" do
+				e = EimXML::DSL.element(:e) do
+					element(:s)
+				end
+				write(e).should == <<EOT
+<e>
+  <s />
+</e>
+EOT
+			end
+
+			it "(elements in element)" do
+				e = EimXML::DSL.element(:e) do
+					element(:s1)
+					element(:s2)
+				end
+				write(e).should == <<EOT
+<e>
+  <s1 />
+  <s2 />
+</e>
+EOT
+			end
+
+			it "(comment in element)" do
+				e = EimXML::DSL.element(:e) do
+					comment("multi\nline\n pre-indented\n  comment")
+				end
+				write(e).should == <<EOT
+<e>
+  <!-- multi
+line
+ pre-indented
+  comment -->
+</e>
+EOT
+			end
+
+			it "(string in element)" do
+				e = EimXML::Element.new(:e)
+				e.add("string")
+				write(e).should == "<e>\n  string\n</e>\n"
+
+				esc = "&<>'\""
+				esc = "&amp;&lt;&gt;\n&apos;&quot;"
+				write(EimXML::Element.new(:e, :a=>"&<>\n'\"").add("&<>\n'\"")).should == "<e a='&amp;&lt;&gt;\n&apos;&quot;'>\n  &amp;&lt;&gt;\n  &apos;&quot;\n</e>\n"
+				write(EimXML::Element.new(:e, :a=>"&<>\n'\"").add(EimXML::PCString.new("&<>\n'\"", true))).should == "<e a='&amp;&lt;&gt;\n&apos;&quot;'>\n  &<>\n  '\"\n</e>\n"
+			end
+
+			it "(multi-line string in element)" do
+				e = EimXML::Element.new(:e)
+				e.add("multi\nline")
+				write(e).should == <<EOT
+<e>
+  multi
+  line
+</e>
+EOT
+			end
+
+			describe "(preserve spaces" do
+				it "name of element" do
+					e = EimXML::DSL.element(:e) do
+						element(:pre1) do
+							element(:sub1).add("text")
+							element(:sub2)
+						end
+						element(:pre2).add("multi\nline\ntext")
+						element(:sub1).add("text")
+					end
+					s = <<EOT
+<e>
+  <pre1><sub1>text</sub1><sub2 /></pre1>
+  <pre2>multi
+line
+text</pre2>
+  <sub1>
+    text
+  </sub1>
+</e>
+EOT
+
+					write(e, :preservers=>[:pre1, :pre2]).should == s
+				end
+
+				it "class of element" do
+					m = Module.new
+					class m::Pre < EimXML::Element
+						def initialize(n=nil)
+							super(n||"pre")
+						end
+					end
+					class m::P1 < m::Pre
+						def initialize(n=nil)
+							super(n||"p1")
+						end
+					end
+					class m::P2 < m::P1
+						def initialize
+							super("p2")
+						end
+					end
+
+					e = EimXML::Element.new(:e)
+					e << m::Pre.new.add("text\nwith\nnewline")
+					e << m::Pre.new("dummy").add("t\nn")
+					e << m::P1.new.add("t1\nn")
+					e << m::P2.new.add("t2\nn")
+					e << m::Pre.new.add(EimXML::Element.new(:s).add("t\ns"))
+					e << m::P2.new.add(EimXML::Element.new(:s).add("t\ns2"))
+					e << EimXML::Element.new(:s).add(EimXML::Element.new(:s).add("t\ns"))
+
+					s = <<EOT
+<e>
+  <pre>text
+with
+newline</pre>
+  <dummy>t
+n</dummy>
+  <p1>t1
+n</p1>
+  <p2>t2
+n</p2>
+  <pre><s>t
+s</s></pre>
+  <p2><s>t
+s2</s></p2>
+  <s>
+    <s>
+      t
+      s
+    </s>
+  </s>
+</e>
+EOT
+					write(e, :preservers=>[m::Pre]).should == s
+				end
+			end
+
+			it "(all)" do
+				s = <<EOT
+<base>
+  <sub1 />
+  <sub2>
+    text2
+  </sub2>
+  <sub3 a1='v1'>
+    <sub31 />
+    <sub32>
+      text32
+    </sub32>
+  </sub3>
+  <sub4>
+    multi-line
+    text
+  </sub4>
+  <sub5>
+    <sub51 />
+    sub52
+    <sub53 />
+    sub54-1
+    sub54-2
+  </sub5>
+</base>
+EOT
+				e = EimXML::DSL.element(:base) do
+					element(:sub1)
+					element(:sub2).add("text2")
+					element(:sub3, :a1=>"v1") do
+						element(:sub31)
+						element(:sub32).add("text32")
+					end
+					element(:sub4).add("multi-line\ntext")
+					element(:sub5) do
+						element(:sub51)
+						add("sub52")
+						element(:sub53)
+						add("sub54-1\nsub54-2")
+					end
+				end
+				write(e).should == s
+			end
+		end
+	end
+end
+
+describe EimXML::Formatter::ElementWrapper do
+	before do
+		@out = ""
+		@opt = {:out=>@out, :preservers=>[], :a=>10, :b=>20}
+		@formatter = EimXML::Formatter.new(@opt)
+		@m = Module.new
+		class @m::Wrapper < EimXML::Formatter::ElementWrapper
+			def initialize(mocks)
+				@mocks = mocks
+			end
+
+			def contents(option)
+				@mocks
+			end
+		end
+		@mocks = [mock(:m1).as_null_object, mock(:m2).as_null_object]
+		@wrapper = @m::Wrapper.new(@mocks)
+		@xml = EimXML::Element.new(:e) do |e|
+			e << @wrapper
+		end
+	end
+
+	describe "#each" do
+		it "will give options from formatter"  do
+			@wrapper.should_receive(:contents).with(:a=>10, :b=>20).and_return([])
+			@formatter.write(@xml)
+		end
+
+		it "yield result of contents" do
+			@mocks.each_with_index do |mock, index|
+				mock.should_receive(:to_s).and_return("m#{index}")
+			end
+			@formatter.write(@xml)
+			@out.should == "<e>\n  m0\n  m1\n</e>\n"
+		end
+
+		it "raise error when subclass of ElementWrapper is not implement #contents" do
+			class @m::Wrapper2 < EimXML::Formatter::ElementWrapper; end
+			@xml << @m::Wrapper2.new
+
+			expect{@formatter.write(@xml)}.to raise_error(NoMethodError)
+		end
+	end
+end

data/spec/parser_spec.rb

@@ -0,0 +1,102 @@
+require "eim_xml/parser"
+
+module Module.new::M
+	include EimXML
+
+	describe Parser do
+		def parse(src)
+			Parser.new(src).parse
+		end
+
+		it "'parser' method for test" do
+			s = " <e /> "
+			parse(s).should == Parser.new(s).parse
+		end
+
+		it "#parse with empty element" do
+			parse("<e />").should == Element.new("e")
+			parse("<e/>").should == Element.new("e")
+
+			parse(%[<e key="value"/>]).should == Element.new("e", :key=>"value")
+			parse(%[<e key='value'/>]).should == Element.new("e", :key=>"value")
+			parse(%[<e key="value" />]).should == Element.new("e", :key=>"value")
+			parse(%[<e key='value' />]).should == Element.new("e", :key=>"value")
+
+			parse(%[<e key="value" key2="value2"/>]).should == Element.new("e", :key=>"value", :key2=>"value2")
+			parse(%[<e key="value" key2="value2" />]).should == Element.new("e", :key=>"value", :key2=>"value2")
+
+			s = " <e1 /> <e2 /> "
+			p = Parser.new(s)
+			p.parse.should == PCString.new(" ")
+			p.parse.should == Element.new("e1")
+			p.parse.should == PCString.new(" ")
+			p.parse.should == Element.new("e2")
+		end
+
+		it "#parse with nonempty element" do
+			parse("<super><sub /></super>").should == Element.new("super") << Element.new("sub")
+
+			parse("<out><in></in></out>").should == Element.new("out") << Element.new("in")
+
+			lambda{parse("<el></e>")}.should raise_error(ParseError, "End tag mismatched.")
+			lambda{parse("<el><></el>")}.should raise_error(ParseError, "Syntax error.")
+		end
+
+		it "#parse with string" do
+			e = parse("string&amp;")
+			e.should be_kind_of(PCString)
+			e.to_s.should == "string&amp;"
+			e = parse(" string &amp; ")
+			e.should be_kind_of(PCString)
+			e.to_s.should == " string &amp; "
+
+			e = Element.new("e")
+			e << PCString.new(" string ")
+			parse("<e> string </e>").should == e
+
+			e = Element.new("e")
+			e << PCString.new("string")
+			parse("<e>string</e>").should == e
+		end
+
+		it "#parse escaped characters" do
+			e = parse("&amp;&quot;&apos;&lt;&gt;")
+			e.to_s.should == "&amp;&quot;&apos;&lt;&gt;"
+			e.src.should == "&\"'<>"
+		end
+
+		it "#parse with holding space" do
+			s = "<e> string with space\n</e>"
+			e = Element.new("e")
+			e << PCString.new(" string with space\n")
+			parse(s).should == e
+			parse(s).to_s.should == s
+
+			s = "<ns:e> string with space\n</ns:e>"
+			e = Element.new("ns:e")
+			e << PCString.new(" string with space\n")
+			parse(s).should == e
+			parse(s).to_s.should == s
+
+			s = "<a> string without space <b> string with space <a> string with space 2 </a> </b>  </a>"
+			oa = Element.new("a") << PCString.new(" string without space ")
+			b = Element.new("b")
+			b << PCString.new(" string with space ")
+			ia = Element.new("a")
+			ia << PCString.new(" string with space 2 ")
+			b << ia
+			b << PCString.new(" ")
+			oa << b
+			oa << PCString.new("  ")
+			parse(s).should == oa
+			parse(s).to_s.should == s
+
+			s = "<a><b/></a>"
+			a = Element.new("a")
+			b = Element.new("b")
+			a << b
+			parse(s).should == a
+			parse(s).to_s.should == "<a><b /></a>"
+		end
+	end
+end

data/spec/xhtml_spec.rb

@@ -0,0 +1,524 @@
+require "stringio"
+require "eim_xml/xhtml/dsl"
+
+module Module.new::M
+	include EimXML
+	include EimXML::XHTML
+	XDSL = XHTML::DSL
+
+	describe XHTML do
+		it "DSL.base_ should raise NoMethodError" do
+			lambda{XDSL.base_}.should raise_error(NoMethodError)
+		end
+
+		it "HTML" do
+			h = HTML.new(:attr=>"value")
+			h.should == Element.new(:html, :attr=>"value")
+
+			h = HTML.new do |e|
+				e <<= Element.new(:sub)
+			end
+			h2 = HTML.new
+			h2 << Element.new(:sub)
+			h2.should == h
+
+			lambda{EimXML::DSL.html}.should raise_error(NoMethodError)
+			XDSL.html(:key=>"v").should == HTML.new(:key=>"v")
+			OpenDSL.html(:key=>"v").should == HTML.new(:key=>"v")
+
+			h = HTML.new
+			h.write_to.should == "<html />"
+			h.prefix='<?xml version="1.0"?>'
+			h.write_to.should == %[<?xml version="1.0"?>\n<html />]
+		end
+
+		it "HEAD" do
+			HEAD.new.name.should == :head
+			XDSL.head.should be_kind_of(HEAD)
+			OpenDSL.head.should be_kind_of(HEAD)
+		end
+
+		it "META" do
+			META.new.name.should == :meta
+			XDSL.meta.should be_kind_of(META)
+			OpenDSL.meta.should be_kind_of(META)
+		end
+
+		it "LINK" do
+			LINK.new.name.should == :link
+			XDSL.link.should be_kind_of(LINK)
+			OpenDSL.link.should be_kind_of(LINK)
+		end
+
+		it "STYLE" do
+			STYLE.new.name.should == :style
+			XDSL.style.should be_kind_of(STYLE)
+			OpenDSL.style.should be_kind_of(STYLE)
+		end
+
+		it "IMG" do
+			IMG.new.name.should == :img
+			XDSL.img.should be_kind_of(IMG)
+			OpenDSL.img.should be_kind_of(IMG)
+		end
+
+		it "SCRIPT" do
+			SCRIPT.new.name.should == :script
+			XDSL.script.should be_kind_of(SCRIPT)
+			OpenDSL.script.should be_kind_of(SCRIPT)
+		end
+
+		it "TITLE" do
+			TITLE.new.name.should == :title
+			XDSL.title.should be_kind_of(TITLE)
+			OpenDSL.title.should be_kind_of(TITLE)
+		end
+
+		it "BODY" do
+			BODY.new.name.should == :body
+			XDSL.body.should be_kind_of(BODY)
+			OpenDSL.body.should be_kind_of(BODY)
+		end
+
+		it "PRE" do
+			PRE.new.name.should == :pre
+			XDSL.pre.should be_kind_of(PRE)
+			OpenDSL.pre.should be_kind_of(PRE)
+		end
+
+		it "Hn" do
+			h1 = Hn.new(1)
+			h6 = Hn.new(6)
+			h1.name.should == :h1
+			h1.should be_kind_of(H1)
+			h6.name.should == :h6
+			h6.should be_kind_of(H6)
+			lambda{Hn.new(7)}.should raise_error(ArgumentError)
+			lambda{Hn.new(0)}.should raise_error(ArgumentError)
+
+			h = Hn.new(1, :key=>:value) do |hn|
+				hn << "test"
+			end
+			h[:key].should == :value
+			h[0].should == "test"
+
+			[
+				[H1, XDSL.h1, OpenDSL.h1],
+				[H2, XDSL.h2, OpenDSL.h2],
+				[H3, XDSL.h3, OpenDSL.h3],
+				[H4, XDSL.h4, OpenDSL.h4],
+				[H5, XDSL.h5, OpenDSL.h5],
+				[H6, XDSL.h6, OpenDSL.h6]
+			].each do |klass, dsl, od|
+				dsl.should be_kind_of(klass)
+				od.should be_kind_of(klass)
+			end
+		end
+
+		it "P" do
+			P.new.name.should == :p
+			XDSL.p.should be_kind_of(P)
+			OpenDSL.p.should be_kind_of(P)
+		end
+
+		it "A" do
+			A.new.name.should == :a
+			XDSL.a.should be_kind_of(A)
+			OpenDSL.a.should be_kind_of(A)
+		end
+
+		it "EM" do
+			EM.new.name.should == :em
+			XDSL.em.should be_kind_of(EM)
+			OpenDSL.em.should be_kind_of(EM)
+		end
+
+		it "STRONG" do
+			STRONG.new.name.should == :strong
+			XDSL.strong.should be_kind_of(STRONG)
+			OpenDSL.strong.should be_kind_of(STRONG)
+		end
+
+		it "DIV" do
+			DIV.new.name.should == :div
+			XDSL.div.should be_kind_of(DIV)
+			OpenDSL.div.should be_kind_of(DIV)
+		end
+
+		it "SPAN" do
+			SPAN.new.name.should == :span
+			XDSL.span.should be_kind_of(SPAN)
+			OpenDSL.span.should be_kind_of(SPAN)
+		end
+
+		it "UL" do
+			UL.new.name.should == :ul
+			XDSL.ul.should be_kind_of(UL)
+			OpenDSL.ul.should be_kind_of(UL)
+		end
+
+		it "OL" do
+			OL.new.name.should == :ol
+			XDSL.ol.should be_kind_of(OL)
+			OpenDSL.ol.should be_kind_of(OL)
+		end
+
+		it "LI" do
+			LI.new.name.should == :li
+			XDSL.li.should be_kind_of(LI)
+			OpenDSL.li.should be_kind_of(LI)
+		end
+
+		it "DL" do
+			DL.new.name.should == :dl
+			XDSL.dl.should be_kind_of(DL)
+			OpenDSL.dl.should be_kind_of(DL)
+		end
+
+		it "DT" do
+			DT.new.name.should == :dt
+			XDSL.dt.should be_kind_of(DT)
+			OpenDSL.dt.should be_kind_of(DT)
+		end
+
+		it "DD" do
+			DD.new.name.should == :dd
+			XDSL.dd.should be_kind_of(DD)
+			OpenDSL.dd.should be_kind_of(DD)
+		end
+
+		it "TABLE" do
+			TABLE.new.name.should == :table
+			XDSL.table.should be_kind_of(TABLE)
+			OpenDSL.table.should be_kind_of(TABLE)
+		end
+
+		it "CAPTION" do
+			CAPTION.new.name.should == :caption
+			XDSL.caption.should be_kind_of(CAPTION)
+			OpenDSL.caption.should be_kind_of(CAPTION)
+		end
+
+		it "TR" do
+			TR.new.name.should == :tr
+			XDSL.tr.should be_kind_of(TR)
+			OpenDSL.tr.should be_kind_of(TR)
+		end
+
+		it "TH" do
+			TH.new.name.should == :th
+			XDSL.th.should be_kind_of(TH)
+			OpenDSL.th.should be_kind_of(TH)
+		end
+
+		it "TD" do
+			TD.new.name.should == :td
+			XDSL.td.should be_kind_of(TD)
+			OpenDSL.td.should be_kind_of(TD)
+		end
+
+		it "FORM" do
+			FORM.new.name.should == :form
+			XDSL.form.should be_kind_of(FORM)
+			OpenDSL.form.should be_kind_of(FORM)
+
+			FORM.new.should_not include(HIDDEN)
+		end
+
+		it "FORM.new should be able to receive CGI::Session object and set random token" do
+			s = mock("session")
+			h = {}
+			s.should_receive(:[]).any_number_of_times{|k| h[k]}
+			s.should_receive(:[]=).any_number_of_times{|k, v| h[k]=v}
+			f = FORM.new(:session=>s)
+			h["token"].size.should == 40
+			h["token"].should =~ /\A[0-9a-f]{40}\z/
+			f.should include(HIDDEN.new(:name=>"token", :value=>h["token"]))
+
+			s = mock("session")
+			h = {}
+			s.should_receive(:[]).any_number_of_times{|k| h[k]}
+			s.should_receive(:[]=).any_number_of_times{|k, v| h[k]=v}
+			f = FORM.new(:session=>s, :session_name=>"random_key")
+			h["token"].should be_nil
+			h["random_key"].size.should == 40
+			h["random_key"].should =~ /\A[0-9a-f]{40}\z/
+			f.should include(HIDDEN.new(:name=>"random_key", :value=>h["random_key"]))
+
+			s = mock("session")
+			h = {}
+			s.should_receive(:[]).any_number_of_times{|k| h[k]}
+			s.should_receive(:[]=).any_number_of_times{|k, v| h[k]=v}
+			FORM.new(:session=>s)
+			token = s["token"]
+			FORM.new(:session=>s).should include(HIDDEN.new(:name=>"token", :value=>token))
+			s["token"].should == token
+		end
+
+		it "TEXTAREA" do
+			TEXTAREA.new(:name=>"item").should == Element.new(:textarea, :name=>"item")
+			TEXTAREA.new(:name=>:item).should == Element.new(:textarea, :name=>:item)
+			TEXTAREA.new(:name=>"item", :class=>"cv").should == Element.new(:textarea, :name=>"item", :class=>"cv")
+
+			t = XDSL.textarea(:name=>"t")
+			t.should be_kind_of(TEXTAREA)
+			t[:name].should == "t"
+
+			t = OpenDSL.textarea(:name=>"t")
+			t.should be_kind_of(TEXTAREA)
+			t[:name].should == "t"
+		end
+
+		it "BUTTON" do
+			BUTTON.new.should == Element.new(:button)
+		end
+
+		it "INPUT" do
+			INPUT.new(:type=>:test, :name=>:item, :value=>"v").should == Element.new(:input, :type=>:test, :name=>:item, :value=>"v")
+			INPUT.new(:type=>"test", :name=>"item", :value=>"v").should == Element.new(:input, :type=>"test", :name=>"item", :value=>"v")
+			INPUT.new(:type=>:test, :name=>:item, :value=>"v", :class=>"c").should == Element.new(:input, :type=>:test, :name=>:item, :value=>"v", :class=>"c")
+
+			INPUT.new(:type=>:submit, :value=>"v").should == Element.new(:input, :type=>:submit, :value=>"v")
+			INPUT.new(:type=>:submit, :name=>"item").should == Element.new(:input, :type=>:submit, :name=>"item")
+
+			i = XDSL.input(:type=>:dummy, :name=>:n, :value=>:v)
+			i.should be_kind_of(INPUT)
+			i.should =~ INPUT.new(:type=>:dummy, :name=>:n, :value=>:v)
+
+			i = OpenDSL.input(:type=>:dummy, :name=>:n, :value=>:v)
+			i.should be_kind_of(INPUT)
+			i.should == INPUT.new(:type=>:dummy, :name=>:n, :value=>:v)
+		end
+
+		it "HIDDEN" do
+			HIDDEN.new(:name=>"item", :value=>"v").should == Element.new(:input, :type=>:hidden, :name=>"item", :value=>"v")
+			HIDDEN.new(:name=>:item, :value=>"v").should == Element.new(:input, :type=>:hidden, :name=>:item, :value=>"v")
+			HIDDEN.new(:name=>:item, :value=>"v", :class=>"c").should == Element.new(:input, :type=>:hidden, :name=>:item, :value=>"v", :class=>"c")
+
+			h = XDSL.hidden(:name=>:n, :value=>:v)
+			h.should be_kind_of(HIDDEN)
+			h.should =~ HIDDEN.new(:name=>:n, :value=>:v)
+
+			h = OpenDSL.hidden(:name=>:n, :value=>:v)
+			h.should be_kind_of(HIDDEN)
+			h.should == HIDDEN.new(:name=>:n, :value=>:v)
+		end
+
+		it "SUBMIT" do
+			SUBMIT.new.should == Element.new(:button, :type=>:submit)
+			SUBMIT.new(:value=>"OK").should == Element.new(:button, :type=>:submit, :value=>"OK")
+			SUBMIT.new(:value=>"OK", :class=>"c").should == Element.new(:button, :type=>:submit, :value=>"OK", :class=>"c")
+			opt = {:value=>"v", :name=>"n"}
+			opt2 = opt.dup
+			SUBMIT.new(opt2)
+			opt2.should == opt
+
+			s = XDSL.submit
+			s.should be_kind_of(SUBMIT)
+			s.should =~ SUBMIT.new
+			(!s[:name]).should be_true
+			(!s[:value]).should be_true
+			s = XDSL.submit(:name=>:s, :value=>:v)
+			s[:name].should == :s
+			s[:value].should == :v
+
+			s = OpenDSL.submit
+			s.should be_kind_of(SUBMIT)
+			s.should == SUBMIT.new
+			s[:name].should be_nil
+			s[:value].should be_nil
+			s = OpenDSL.submit(:name=>:s, :value=>:v)
+			s.should == SUBMIT.new(:name=>:s, :value=>:v)
+		end
+
+		it "TEXT" do
+			TEXT.new(:name=>:item).should == Element.new(:input, :type=>:text, :name=>:item)
+			TEXT.new(:name=>"item").should == Element.new(:input, :type=>:text, :name=>"item")
+			TEXT.new(:name=>:item, :value=>"txt").should == Element.new(:input, :type=>:text, :name=>:item, :value=>"txt")
+			TEXT.new(:name=>:item, :value=>"txt", :class=>"c").should == Element.new(:input, :type=>:text, :name=>:item, :value=>"txt", :class=>"c")
+
+			t = XDSL.text(:name=>:n, :value=>:v)
+			t.should be_kind_of(TEXT)
+			t.should =~ TEXT.new(:name=>:n, :value=>:v)
+
+			t = OpenDSL.text(:name=>:n, :value=>:v)
+			t.should be_kind_of(TEXT)
+			t.should == TEXT.new(:name=>:n, :value=>:v)
+		end
+
+		it "PASSWORD" do
+			PASSWORD.new(:name=>:item).should == Element.new(:input, :type=>:password, :name=>:item)
+			PASSWORD.new(:name=>"item").should == Element.new(:input, :type=>:password, :name=>"item")
+			PASSWORD.new(:name=>:item, :value=>"txt").should == Element.new(:input, :type=>:password, :name=>:item, :value=>"txt")
+			PASSWORD.new(:name=>:item, :value=>"txt", :class=>"c").should == Element.new(:input, :type=>:password, :name=>:item, :value=>"txt", :class=>"c")
+
+			t = XDSL.password(:name=>:n, :value=>:v)
+			t.should be_kind_of(PASSWORD)
+			t.should =~ PASSWORD.new(:name=>:n, :value=>:v)
+
+			t = OpenDSL.password(:name=>:n, :value=>:v)
+			t.should be_kind_of(PASSWORD)
+			t.should == PASSWORD.new(:name=>:n, :value=>:v)
+		end
+
+		it "FILE" do
+			FILE.new(:name=>:foo).should == Element.new(:input, :type=>:file, :name=>:foo)
+			XDSL.file(:name=>:foo).should =~ FILE.new(:name=>:foo)
+
+			OpenDSL.file(:name=>:foo).should == FILE.new(:name=>:foo)
+		end
+
+		it "SELECT" do
+			SELECT.new(:name=>:foo).should == Element.new(:select, :name=>:foo)
+			XDSL.select(:name=>:foo).should == SELECT.new(:name=>:foo)
+
+			OpenDSL.select(:name=>:foo).should == SELECT.new(:name=>:foo)
+		end
+
+		it "OPTION" do
+			OPTION.new(:value=>:bar, :selected=>true){|e| e << "TEXT"}.should == Element.new(:option, :value=>:bar, :selected=>true){|e| e.add("TEXT")}
+			XDSL.option(:value=>:bar).should == OPTION.new(:value=>:bar)
+
+			OpenDSL.option(:value=>:bar).should == OPTION.new(:value=>:bar)
+		end
+
+		it "BR" do
+			BR.new.name.should == :br
+			XDSL.br.should be_kind_of(BR)
+			OpenDSL.br.should be_kind_of(BR)
+		end
+
+		it "HR" do
+			HR.new.name.should == :hr
+			XDSL.hr.should be_kind_of(HR)
+			OpenDSL.hr.should be_kind_of(HR)
+		end
+	end
+
+	describe EimXML::XHTML::OpenDSL do
+		it "replace EimXML::XHTML::DSL" do
+			e = EimXML::XHTML::OpenDSL.html do |d|
+				d.head do
+					d.title.add "Title"
+				end
+				d.body do
+					d.h1.add "Sample"
+					d.p do
+						d.add "text"
+						d.add "next"
+					end
+				end
+			end
+			e.should == EimXML::XHTML::DSL.html do
+				head do
+					title.add "Title"
+				end
+				body do
+					h1.add "Sample"
+					p do
+						add "text"
+						add "next"
+					end
+				end
+			end
+		end
+	end
+
+	describe EimXML::XHTML::Formatter do
+		describe "#write" do
+			it "should set :preservers=>PRESERVE_SPACES to default option" do
+				e = EimXML::XHTML::HTML.new
+				EimXML::Formatter.should_receive(:write).with(e, :preservers=>EimXML::XHTML::PRESERVE_SPACES, :opt=>:dummy)
+				EimXML::XHTML::Formatter.write(e, :opt=>:dummy)
+			end
+
+			it "should return string" do
+				h = EimXML::XHTML::DSL.html do
+					head do
+						style.add("style\ntext")
+						script.add("script\ntext")
+					end
+					body do
+						div.add("text\nin\ndiv")
+						pre.add("pre\nt")
+						h1.add("1\nt")
+						h2.add("2\nt")
+						h3.add("3\nt")
+						h4.add("4\nt")
+						h5.add("5\nt")
+						h6.add("6\nt")
+						p.add("p\nt")
+						a.add("a\nt")
+						em.add("e\nt")
+						strong.add("s\nt")
+						span.add("sp\nt")
+						li.add("li\nt")
+						dt.add("dt\nt")
+						dd.add("dd\nt")
+						caption.add("c\nt")
+						th.add("th\nt")
+						td.add("td\nt")
+						button.add("button\nt")
+					end
+				end
+
+				s = <<EOT
+<html>
+  <head>
+    <style>style
+text</style>
+    <script>script
+text</script>
+  </head>
+  <body>
+    <div>
+      text
+      in
+      div
+    </div>
+    <pre>pre
+t</pre>
+    <h1>1
+t</h1>
+    <h2>2
+t</h2>
+    <h3>3
+t</h3>
+    <h4>4
+t</h4>
+    <h5>5
+t</h5>
+    <h6>6
+t</h6>
+    <p>p
+t</p>
+    <a>a
+t</a>
+    <em>e
+t</em>
+    <strong>s
+t</strong>
+    <span>sp
+t</span>
+    <li>li
+t</li>
+    <dt>dt
+t</dt>
+    <dd>dd
+t</dd>
+    <caption>c
+t</caption>
+    <th>th
+t</th>
+    <td>td
+t</td>
+    <button>button
+t</button>
+  </body>
+</html>
+EOT
+				EimXML::XHTML::Formatter.write(h).should == s
+			end
+		end
+	end
+end