ruby_speech 2.1.2-java → 2.2.0-java

data/spec/ruby_speech/ssml/p_spec.rb

@@ -3,10 +3,14 @@ require 'spec_helper'
 module RubySpeech
   module SSML
     describe P do
+      let(:doc) { Nokogiri::XML::Document.new }
+
+      subject { described_class.new doc }
+
       its(:name) { should == 'p' }
 
       describe "setting options in initializers" do
-        subject { P.new :language => 'jp' }
+        subject { P.new doc, :language => 'jp' }
 
         its(:language) { should == 'jp' }
       end
@@ -26,18 +30,18 @@ module RubySpeech
 
       describe "comparing objects" do
         it "should be equal if the content and language are the same" do
-          P.new(:language => 'jp', :content => "Hello there").should == P.new(:language => 'jp', :content => "Hello there")
+          P.new(doc, :language => 'jp', :content => "Hello there").should == P.new(doc, :language => 'jp', :content => "Hello there")
         end
 
         describe "when the content is different" do
           it "should not be equal" do
-            P.new(:content => "Hello").should_not == P.new(:content => "Hello there")
+            P.new(doc, :content => "Hello").should_not == P.new(doc, :content => "Hello there")
           end
         end
 
         describe "when the language is different" do
           it "should not be equal" do
-            P.new(:language => 'jp').should_not == P.new(:language => 'en')
+            P.new(doc, :language => 'jp').should_not == P.new(doc, :language => 'en')
           end
         end
       end
@@ -48,43 +52,43 @@ module RubySpeech
         end
 
         it "should accept Audio" do
-          lambda { subject << Audio.new }.should_not raise_error
+          lambda { subject << Audio.new(doc) }.should_not raise_error
         end
 
         it "should accept Break" do
-          lambda { subject << Break.new }.should_not raise_error
+          lambda { subject << Break.new(doc) }.should_not raise_error
         end
 
         it "should accept Emphasis" do
-          lambda { subject << Emphasis.new }.should_not raise_error
+          lambda { subject << Emphasis.new(doc) }.should_not raise_error
         end
 
         it "should accept Mark" do
-          lambda { subject << Mark.new }.should_not raise_error
+          lambda { subject << Mark.new(doc) }.should_not raise_error
         end
 
         it "should accept Phoneme" do
-          lambda { subject << Phoneme.new }.should_not raise_error
+          lambda { subject << Phoneme.new(doc) }.should_not raise_error
         end
 
         it "should accept Prosody" do
-          lambda { subject << Prosody.new }.should_not raise_error
+          lambda { subject << Prosody.new(doc) }.should_not raise_error
         end
 
         it "should accept SayAs" do
-          lambda { subject << SayAs.new(:interpret_as => :foo) }.should_not raise_error
+          lambda { subject << SayAs.new(doc, :interpret_as => :foo) }.should_not raise_error
         end
 
         it "should accept Sub" do
-          lambda { subject << Sub.new }.should_not raise_error
+          lambda { subject << Sub.new(doc) }.should_not raise_error
         end
 
         it "should accept S" do
-          lambda { subject << S.new }.should_not raise_error
+          lambda { subject << S.new(doc) }.should_not raise_error
         end
 
         it "should accept Voice" do
-          lambda { subject << Voice.new }.should_not raise_error
+          lambda { subject << Voice.new(doc) }.should_not raise_error
         end
 
         it "should raise InvalidChildError with non-acceptable objects" do

data/spec/ruby_speech/ssml/phoneme_spec.rb

@@ -3,10 +3,14 @@ require 'spec_helper'
 module RubySpeech
   module SSML
     describe Phoneme do
+      let(:doc) { Nokogiri::XML::Document.new }
+
+      subject { described_class.new doc }
+
       its(:name) { should == 'phoneme' }
 
       describe "setting options in initializers" do
-        subject { Phoneme.new :alphabet => 'foo', :ph => 'bar' }
+        subject { Phoneme.new doc, :alphabet => 'foo', :ph => 'bar' }
 
         its(:alphabet) { should == 'foo' }
         its(:ph)       { should == 'bar' }
@@ -29,24 +33,24 @@ module RubySpeech
 
       describe "comparing objects" do
         it "should be equal if the content, ph and alphabet are the same" do
-          Phoneme.new(:alphabet => 'jp', :ph => 'foo', :content => "Hello there").should == Phoneme.new(:alphabet => 'jp', :ph => 'foo', :content => "Hello there")
+          Phoneme.new(doc, :alphabet => 'jp', :ph => 'foo', :content => "Hello there").should == Phoneme.new(doc, :alphabet => 'jp', :ph => 'foo', :content => "Hello there")
         end
 
         describe "when the content is different" do
           it "should not be equal" do
-            Phoneme.new(:content => "Hello").should_not == Phoneme.new(:content => "Hello there")
+            Phoneme.new(doc, :content => "Hello").should_not == Phoneme.new(doc, :content => "Hello there")
           end
         end
 
         describe "when the ph is different" do
           it "should not be equal" do
-            Phoneme.new(:ph => 'jp').should_not == Phoneme.new(:ph => 'en')
+            Phoneme.new(doc, :ph => 'jp').should_not == Phoneme.new(doc, :ph => 'en')
           end
         end
 
         describe "when the alphabet is different" do
           it "should not be equal" do
-            Phoneme.new(:alphabet => 'jp').should_not == Phoneme.new(:alphabet => 'en')
+            Phoneme.new(doc, :alphabet => 'jp').should_not == Phoneme.new(doc, :alphabet => 'en')
           end
         end
       end
@@ -57,7 +61,7 @@ module RubySpeech
         end
 
         it "should raise InvalidChildError with non-acceptable objects" do
-          lambda { subject << Voice.new }.should raise_error(InvalidChildError, "A Phoneme can only accept Strings as children")
+          lambda { subject << Voice.new(doc) }.should raise_error(InvalidChildError, "A Phoneme can only accept Strings as children")
         end
       end
     end # Desc

data/spec/ruby_speech/ssml/prosody_spec.rb

@@ -3,16 +3,20 @@ require 'spec_helper'
 module RubySpeech
   module SSML
     describe Prosody do
+      let(:doc) { Nokogiri::XML::Document.new }
+
+      subject { described_class.new doc }
+
       its(:name) { should == 'prosody' }
 
       describe "setting options in initializers" do
-        subject { Prosody.new :pitch => :medium, :contour => "something", :range => '20Hz', :rate => 2, :duration => 10.seconds, :volume => :loud }
+        subject { Prosody.new doc, :pitch => :medium, :contour => "something", :range => '20Hz', :rate => 2, :duration => 10, :volume => :loud }
 
         its(:pitch)     { should == :medium }
         its(:contour)   { should == 'something' }
         its(:range)     { should == '20Hz' }
         its(:rate)      { should == 2 }
-        its(:duration)  { should == 10.seconds }
+        its(:duration)  { should == 10 }
         its(:volume)    { should == :loud }
       end
 
@@ -31,7 +35,7 @@ module RubySpeech
         its(:contour)   { should == 'something' }
         its(:range)     { should == '20Hz' }
         its(:rate)      { should == 2 }
-        its(:duration)  { should == 10.seconds }
+        its(:duration)  { should == 10 }
         its(:volume)    { should == :loud }
       end
 
@@ -150,14 +154,14 @@ module RubySpeech
 
       describe "#duration" do
         context "with a valid value" do
-          before { subject.duration = 3.seconds }
+          before { subject.duration = 3 }
 
-          its(:duration) { should == 3.seconds }
+          its(:duration) { should == 3 }
         end
 
         context "with a negative value" do
           it do
-            lambda { subject.duration = -3.seconds }.should raise_error(ArgumentError, "You must specify a valid duration (positive float value in seconds)")
+            lambda { subject.duration = -3 }.should raise_error(ArgumentError, "You must specify a valid duration (positive float value in seconds)")
           end
         end
 
@@ -205,48 +209,48 @@ module RubySpeech
 
       describe "comparing objects" do
         it "should be equal if the content, strength and base uri are the same" do
-          Prosody.new(:pitch => :medium, :contour => "something", :range => '20Hz', :rate => 2, :duration => 10.seconds, :volume => :loud, :content => "Hello there").should == Prosody.new(:pitch => :medium, :contour => "something", :range => '20Hz', :rate => 2, :duration => 10.seconds, :volume => :loud, :content => "Hello there")
+          Prosody.new(doc, :pitch => :medium, :contour => "something", :range => '20Hz', :rate => 2, :duration => 10, :volume => :loud, :content => "Hello there").should == Prosody.new(doc, :pitch => :medium, :contour => "something", :range => '20Hz', :rate => 2, :duration => 10, :volume => :loud, :content => "Hello there")
         end
 
         describe "when the content is different" do
           it "should not be equal" do
-            Prosody.new(:content => "Hello").should_not == Prosody.new(:content => "Hello there")
+            Prosody.new(doc, :content => "Hello").should_not == Prosody.new(doc, :content => "Hello there")
           end
         end
 
         describe "when the pitch is different" do
           it "should not be equal" do
-            Prosody.new(:pitch => :medium).should_not == Prosody.new(:pitch => :high)
+            Prosody.new(doc, :pitch => :medium).should_not == Prosody.new(doc, :pitch => :high)
           end
         end
 
         describe "when the contour is different" do
           it "should not be equal" do
-            Prosody.new(:contour => 'foo').should_not == Prosody.new(:contour => 'bar')
+            Prosody.new(doc, :contour => 'foo').should_not == Prosody.new(doc, :contour => 'bar')
           end
         end
 
         describe "when the range is different" do
           it "should not be equal" do
-            Prosody.new(:range => '20Hz').should_not == Prosody.new(:range => '30Hz')
+            Prosody.new(doc, :range => '20Hz').should_not == Prosody.new(doc, :range => '30Hz')
           end
         end
 
         describe "when the rate is different" do
           it "should not be equal" do
-            Prosody.new(:rate => 2).should_not == Prosody.new(:rate => 3)
+            Prosody.new(doc, :rate => 2).should_not == Prosody.new(doc, :rate => 3)
           end
         end
 
         describe "when the duration is different" do
           it "should not be equal" do
-            Prosody.new(:duration => 10.seconds).should_not == Prosody.new(:duration => 20.seconds)
+            Prosody.new(doc, :duration => 10).should_not == Prosody.new(doc, :duration => 20)
           end
         end
 
         describe "when the volume is different" do
           it "should not be equal" do
-            Prosody.new(:volume => :loud).should_not == Prosody.new(:volume => :soft)
+            Prosody.new(doc, :volume => :loud).should_not == Prosody.new(doc, :volume => :soft)
           end
         end
       end
@@ -257,47 +261,47 @@ module RubySpeech
         end
 
         it "should accept Audio" do
-          lambda { subject << Audio.new }.should_not raise_error
+          lambda { subject << Audio.new(doc) }.should_not raise_error
         end
 
         it "should accept Break" do
-          lambda { subject << Break.new }.should_not raise_error
+          lambda { subject << Break.new(doc) }.should_not raise_error
         end
 
         it "should accept Emphasis" do
-          lambda { subject << Emphasis.new }.should_not raise_error
+          lambda { subject << Emphasis.new(doc) }.should_not raise_error
         end
 
         it "should accept Mark" do
-          lambda { subject << Mark.new }.should_not raise_error
+          lambda { subject << Mark.new(doc) }.should_not raise_error
         end
 
         it "should accept P" do
-          lambda { subject << P.new }.should_not raise_error
+          lambda { subject << P.new(doc) }.should_not raise_error
         end
 
         it "should accept Phoneme" do
-          lambda { subject << Phoneme.new }.should_not raise_error
+          lambda { subject << Phoneme.new(doc) }.should_not raise_error
         end
 
         it "should accept Prosody" do
-          lambda { subject << Prosody.new }.should_not raise_error
+          lambda { subject << Prosody.new(doc) }.should_not raise_error
         end
 
         it "should accept S" do
-          lambda { subject << S.new }.should_not raise_error
+          lambda { subject << S.new(doc) }.should_not raise_error
         end
 
         it "should accept SayAs" do
-          lambda { subject << SayAs.new(:interpret_as => :foo) }.should_not raise_error
+          lambda { subject << SayAs.new(doc, :interpret_as => :foo) }.should_not raise_error
         end
 
         it "should accept Sub" do
-          lambda { subject << Sub.new }.should_not raise_error
+          lambda { subject << Sub.new(doc) }.should_not raise_error
         end
 
         it "should accept Voice" do
-          lambda { subject << Voice.new }.should_not raise_error
+          lambda { subject << Voice.new(doc) }.should_not raise_error
         end
 
         it "should raise InvalidChildError with non-acceptable objects" do

data/spec/ruby_speech/ssml/s_spec.rb

@@ -3,10 +3,14 @@ require 'spec_helper'
 module RubySpeech
   module SSML
     describe S do
+      let(:doc) { Nokogiri::XML::Document.new }
+
+      subject { described_class.new doc }
+
       its(:name) { should == 's' }
 
       describe "setting options in initializers" do
-        subject { S.new :language => 'jp' }
+        subject { S.new doc, :language => 'jp' }
 
         its(:language) { should == 'jp' }
       end
@@ -26,18 +30,18 @@ module RubySpeech
 
       describe "comparing objects" do
         it "should be equal if the content and language are the same" do
-          S.new(:language => 'jp', :content => "Hello there").should == S.new(:language => 'jp', :content => "Hello there")
+          S.new(doc, :language => 'jp', :content => "Hello there").should == S.new(doc, :language => 'jp', :content => "Hello there")
         end
 
         describe "when the content is different" do
           it "should not be equal" do
-            S.new(:content => "Hello").should_not == S.new(:content => "Hello there")
+            S.new(doc, :content => "Hello").should_not == S.new(doc, :content => "Hello there")
           end
         end
 
         describe "when the language is different" do
           it "should not be equal" do
-            S.new(:language => 'jp').should_not == S.new(:language => 'en')
+            S.new(doc, :language => 'jp').should_not == S.new(doc, :language => 'en')
           end
         end
       end
@@ -48,39 +52,39 @@ module RubySpeech
         end
 
         it "should accept Audio" do
-          lambda { subject << Audio.new }.should_not raise_error
+          lambda { subject << Audio.new(doc) }.should_not raise_error
         end
 
         it "should accept Break" do
-          lambda { subject << Break.new }.should_not raise_error
+          lambda { subject << Break.new(doc) }.should_not raise_error
         end
 
         it "should accept Emphasis" do
-          lambda { subject << Emphasis.new }.should_not raise_error
+          lambda { subject << Emphasis.new(doc) }.should_not raise_error
         end
 
         it "should accept Mark" do
-          lambda { subject << Mark.new }.should_not raise_error
+          lambda { subject << Mark.new(doc) }.should_not raise_error
         end
 
         it "should accept Phoneme" do
-          lambda { subject << Phoneme.new }.should_not raise_error
+          lambda { subject << Phoneme.new(doc) }.should_not raise_error
         end
 
         it "should accept Prosody" do
-          lambda { subject << Prosody.new }.should_not raise_error
+          lambda { subject << Prosody.new(doc) }.should_not raise_error
         end
 
         it "should accept SayAs" do
-          lambda { subject << SayAs.new(:interpret_as => :foo) }.should_not raise_error
+          lambda { subject << SayAs.new(doc, :interpret_as => :foo) }.should_not raise_error
         end
 
         it "should accept Sub" do
-          lambda { subject << Sub.new }.should_not raise_error
+          lambda { subject << Sub.new(doc) }.should_not raise_error
         end
 
         it "should accept Voice" do
-          lambda { subject << Voice.new }.should_not raise_error
+          lambda { subject << Voice.new(doc) }.should_not raise_error
         end
 
         it "should raise InvalidChildError with non-acceptable objects" do

data/spec/ruby_speech/ssml/say_as_spec.rb

@@ -3,7 +3,11 @@ require 'spec_helper'
 module RubySpeech
   module SSML
     describe SayAs do
-      subject { SayAs.new :interpret_as => 'one', :format => 'two', :detail => 'three' }
+      let(:doc) { Nokogiri::XML::Document.new }
+
+      subject { described_class.new doc }
+
+      subject { SayAs.new doc, :interpret_as => 'one', :format => 'two', :detail => 'three' }
 
       its(:name) { should == 'say-as' }
 
@@ -29,30 +33,30 @@ module RubySpeech
 
       describe "comparing objects" do
         it "should be equal if the content, interpret_as, format, age, variant, name are the same" do
-          SayAs.new(:interpret_as => 'jp', :format => 'foo', :detail => 'bar', :content => "hello").should == SayAs.new(:interpret_as => 'jp', :format => 'foo', :detail => 'bar', :content => "hello")
+          SayAs.new(doc, :interpret_as => 'jp', :format => 'foo', :detail => 'bar', :content => "hello").should == SayAs.new(doc, :interpret_as => 'jp', :format => 'foo', :detail => 'bar', :content => "hello")
         end
 
         describe "when the content is different" do
           it "should not be equal" do
-            SayAs.new(:interpret_as => 'jp', :content => "Hello").should_not == SayAs.new(:interpret_as => 'jp', :content => "Hello there")
+            SayAs.new(doc, :interpret_as => 'jp', :content => "Hello").should_not == SayAs.new(doc, :interpret_as => 'jp', :content => "Hello there")
           end
         end
 
         describe "when the interpret_as is different" do
           it "should not be equal" do
-            SayAs.new(:interpret_as => "Hello").should_not == SayAs.new(:interpret_as => "Hello there")
+            SayAs.new(doc, :interpret_as => "Hello").should_not == SayAs.new(doc, :interpret_as => "Hello there")
           end
         end
 
         describe "when the format is different" do
           it "should not be equal" do
-            SayAs.new(:interpret_as => 'jp', :format => 'foo').should_not == SayAs.new(:interpret_as => 'jp', :format => 'bar')
+            SayAs.new(doc, :interpret_as => 'jp', :format => 'foo').should_not == SayAs.new(doc, :interpret_as => 'jp', :format => 'bar')
           end
         end
 
         describe "when the detail is different" do
           it "should not be equal" do
-            SayAs.new(:interpret_as => 'jp', :detail => 'foo').should_not == SayAs.new(:interpret_as => 'jp', :detail => 'bar')
+            SayAs.new(doc, :interpret_as => 'jp', :detail => 'foo').should_not == SayAs.new(doc, :interpret_as => 'jp', :detail => 'bar')
           end
         end
       end
@@ -63,7 +67,7 @@ module RubySpeech
         end
 
         it "should raise InvalidChildError with non-acceptable objects" do
-          lambda { subject << Voice.new }.should raise_error(InvalidChildError, "A SayAs can only accept Strings as children")
+          lambda { subject << Voice.new(doc) }.should raise_error(InvalidChildError, "A SayAs can only accept Strings as children")
         end
       end
     end # SayAs

data/spec/ruby_speech/ssml/speak_spec.rb

@@ -3,13 +3,17 @@ require 'spec_helper'
 module RubySpeech
   module SSML
     describe Speak do
+      let(:doc) { Nokogiri::XML::Document.new }
+
+      subject { described_class.new doc }
+
       it { should be_a_valid_ssml_document }
 
       its(:name) { should == 'speak' }
       its(:language) { should == 'en-US' }
 
       describe "setting options in initializers" do
-        subject { Speak.new :language => 'jp', :base_uri => 'blah' }
+        subject { Speak.new doc, :language => 'jp', :base_uri => 'blah' }
 
         its(:language) { should == 'jp' }
         its(:base_uri) { should == 'blah' }
@@ -44,33 +48,33 @@ module RubySpeech
 
       describe "comparing objects" do
         it "should be equal if the content, language and base uri are the same" do
-          Speak.new(:language => 'en-GB', :base_uri => 'blah', :content => "Hello there").should == Speak.new(:language => 'en-GB', :base_uri => 'blah', :content => "Hello there")
+          Speak.new(doc, :language => 'en-GB', :base_uri => 'blah', :content => "Hello there").should == Speak.new(doc, :language => 'en-GB', :base_uri => 'blah', :content => "Hello there")
         end
 
         describe "when the content is different" do
           it "should not be equal" do
-            Speak.new(:content => "Hello").should_not == Speak.new(:content => "Hello there")
+            Speak.new(doc, :content => "Hello").should_not == Speak.new(doc, :content => "Hello there")
           end
         end
 
         describe "when the language is different" do
           it "should not be equal" do
-            Speak.new(:language => 'en-US').should_not == Speak.new(:language => 'en-GB')
+            Speak.new(doc, :language => 'en-US').should_not == Speak.new(doc, :language => 'en-GB')
           end
         end
 
         describe "when the base URI is different" do
           it "should not be equal" do
-            Speak.new(:base_uri => 'foo').should_not == Speak.new(:base_uri => 'bar')
+            Speak.new(doc, :base_uri => 'foo').should_not == Speak.new(doc, :base_uri => 'bar')
           end
         end
 
         describe "when the children are different" do
           it "should not be equal" do
-            s1 = Speak.new
-            s1 << SayAs.new(:interpret_as => 'date')
-            s2 = Speak.new
-            s2 << SayAs.new(:interpret_as => 'time')
+            s1 = Speak.new doc
+            s1 << SayAs.new(doc, :interpret_as => 'date')
+            s2 = Speak.new doc
+            s2 << SayAs.new(doc, :interpret_as => 'time')
 
             s1.should_not == s2
           end
@@ -78,10 +82,10 @@ module RubySpeech
       end
 
       it "should allow creating child SSML elements" do
-        s = Speak.new
+        s = Speak.new doc
         s.voice :gender => :male, :content => 'Hello'
-        expected_s = Speak.new
-        expected_s << Voice.new(:gender => :male, :content => 'Hello')
+        expected_s = Speak.new doc
+        expected_s << Voice.new(doc, :gender => :male, :content => 'Hello')
         s.should == expected_s
       end
 
@@ -91,47 +95,47 @@ module RubySpeech
         end
 
         it "should accept Audio" do
-          lambda { subject << Audio.new }.should_not raise_error
+          lambda { subject << Audio.new(doc) }.should_not raise_error
         end
 
         it "should accept Break" do
-          lambda { subject << Break.new }.should_not raise_error
+          lambda { subject << Break.new(doc) }.should_not raise_error
         end
 
         it "should accept Emphasis" do
-          lambda { subject << Emphasis.new }.should_not raise_error
+          lambda { subject << Emphasis.new(doc) }.should_not raise_error
         end
 
         it "should accept Mark" do
-          lambda { subject << Mark.new }.should_not raise_error
+          lambda { subject << Mark.new(doc) }.should_not raise_error
         end
 
         it "should accept P" do
-          lambda { subject << P.new }.should_not raise_error
+          lambda { subject << P.new(doc) }.should_not raise_error
         end
 
         it "should accept Phoneme" do
-          lambda { subject << Phoneme.new }.should_not raise_error
+          lambda { subject << Phoneme.new(doc) }.should_not raise_error
         end
 
         it "should accept Prosody" do
-          lambda { subject << Prosody.new }.should_not raise_error
+          lambda { subject << Prosody.new(doc) }.should_not raise_error
         end
 
         it "should accept SayAs" do
-          lambda { subject << SayAs.new(:interpret_as => :foo) }.should_not raise_error
+          lambda { subject << SayAs.new(doc, :interpret_as => :foo) }.should_not raise_error
         end
 
         it "should accept Sub" do
-          lambda { subject << Sub.new }.should_not raise_error
+          lambda { subject << Sub.new(doc) }.should_not raise_error
         end
 
         it "should accept S" do
-          lambda { subject << S.new }.should_not raise_error
+          lambda { subject << S.new(doc) }.should_not raise_error
         end
 
         it "should accept Voice" do
-          lambda { subject << Voice.new }.should_not raise_error
+          lambda { subject << Voice.new(doc) }.should_not raise_error
         end
 
         it "should raise InvalidChildError with non-acceptable objects" do
@@ -146,19 +150,31 @@ module RubySpeech
       end
 
       it "should allow concatenation" do
-        speak1 = Speak.new
-        speak1 << Voice.new(:name => 'frank', :content => "Hi, I'm Frank")
-        speak2 = Speak.new
-        speak2 << "Hello there"
-        speak2 << Voice.new(:name => 'millie', :content => "Hi, I'm Millie")
+        speak1 = SSML.draw do
+          voice :name => 'frank' do
+            "Hi, I'm Frank"
+          end
+        end
+        speak2 = SSML.draw do
+          string "Hello there"
+          voice :name => 'millie' do
+            "Hi, I'm Millie"
+          end
+        end
 
-        expected_concat = Speak.new
-        expected_concat << Voice.new(:name => 'frank', :content => "Hi, I'm Frank")
-        expected_concat << "Hello there"
-        expected_concat << Voice.new(:name => 'millie', :content => "Hi, I'm Millie")
+        expected_concat = SSML.draw do
+          voice :name => 'frank' do
+            "Hi, I'm Frank"
+          end
+          string "Hello there"
+          voice :name => 'millie' do
+            "Hi, I'm Millie"
+          end
+        end
 
         concat = (speak1 + speak2)
         concat.should == expected_concat
+        concat.document.root.should == concat
         concat.to_s.should_not include('default')
       end
     end # Speak