ruby_speech 2.3.1-java → 3.0.1-java

data/spec/ruby_speech/ssml/audio_spec.rb

@@ -17,7 +17,7 @@ module RubySpeech
       end
 
       it 'registers itself' do
-        Element.class_from_registration(:audio).should == Audio
+        expect(Element.class_from_registration(:audio)).to eq(Audio)
       end
 
       describe "from a document" do
@@ -25,7 +25,7 @@ module RubySpeech
 
         subject { Element.import document }
 
-        it { should be_instance_of Audio }
+        it { is_expected.to be_instance_of Audio }
 
         its(:src)     { should == 'http://whatever.you-say-boss.com' }
         its(:content) { should == 'Hello' }
@@ -47,76 +47,76 @@ module RubySpeech
 
       describe "<<" do
         it "should accept String" do
-          lambda { subject << 'anything' }.should_not raise_error
+          expect { subject << 'anything' }.not_to raise_error
         end
 
         it "should accept Audio" do
-          lambda { subject << Audio.new(doc) }.should_not raise_error
+          expect { subject << Audio.new(doc) }.not_to raise_error
         end
 
         it "should accept Break" do
-          lambda { subject << Break.new(doc) }.should_not raise_error
+          expect { subject << Break.new(doc) }.not_to raise_error
         end
 
         it "should accept Desc" do
-          lambda { subject << Desc.new(doc) }.should_not raise_error
+          expect { subject << Desc.new(doc) }.not_to raise_error
         end
 
         it "should accept Emphasis" do
-          lambda { subject << Emphasis.new(doc) }.should_not raise_error
+          expect { subject << Emphasis.new(doc) }.not_to raise_error
         end
 
         it "should accept Mark" do
-          lambda { subject << Mark.new(doc) }.should_not raise_error
+          expect { subject << Mark.new(doc) }.not_to raise_error
         end
 
         it "should accept P" do
-          lambda { subject << P.new(doc) }.should_not raise_error
+          expect { subject << P.new(doc) }.not_to raise_error
         end
 
         it "should accept Phoneme" do
-          lambda { subject << Phoneme.new(doc) }.should_not raise_error
+          expect { subject << Phoneme.new(doc) }.not_to raise_error
         end
 
         it "should accept Prosody" do
-          lambda { subject << Prosody.new(doc) }.should_not raise_error
+          expect { subject << Prosody.new(doc) }.not_to raise_error
         end
 
         it "should accept SayAs" do
-          lambda { subject << SayAs.new(doc, :interpret_as => :foo) }.should_not raise_error
+          expect { subject << SayAs.new(doc, :interpret_as => :foo) }.not_to raise_error
         end
 
         it "should accept Sub" do
-          lambda { subject << Sub.new(doc) }.should_not raise_error
+          expect { subject << Sub.new(doc) }.not_to raise_error
         end
 
         it "should accept S" do
-          lambda { subject << S.new(doc) }.should_not raise_error
+          expect { subject << S.new(doc) }.not_to raise_error
         end
 
         it "should accept Voice" do
-          lambda { subject << Voice.new(doc) }.should_not raise_error
+          expect { subject << Voice.new(doc) }.not_to raise_error
         end
 
         it "should raise InvalidChildError with non-acceptable objects" do
-          lambda { subject << 1 }.should raise_error(InvalidChildError, "An Audio can only accept String, Audio, Break, Emphasis, Mark, P, Phoneme, Prosody, SayAs, Sub, S, Voice as children")
+          expect { subject << 1 }.to raise_error(InvalidChildError, "An Audio can only accept String, Audio, Break, Emphasis, Mark, P, Phoneme, Prosody, SayAs, Sub, S, Voice as children")
         end
       end
 
       describe "comparing objects" do
         it "should be equal if the content, and src are the same" do
-          Audio.new(doc, :src => "one", :content => "Hello there").should == Audio.new(doc, :src => "one", :content => "Hello there")
+          expect(Audio.new(doc, :src => "one", :content => "Hello there")).to eq(Audio.new(doc, :src => "one", :content => "Hello there"))
         end
 
         describe "when the content is different" do
           it "should not be equal" do
-            Audio.new(doc, :content => "Hello").should_not == Audio.new(doc, :content => "Hello there")
+            expect(Audio.new(doc, :content => "Hello")).not_to eq(Audio.new(doc, :content => "Hello there"))
           end
         end
 
         describe "when the src is different" do
           it "should not be equal" do
-            Audio.new(doc, :src => 'one').should_not == Audio.new(doc, :src => 'two')
+            expect(Audio.new(doc, :src => 'one')).not_to eq(Audio.new(doc, :src => 'two'))
           end
         end
       end

data/spec/ruby_speech/ssml/break_spec.rb

@@ -17,18 +17,32 @@ module RubySpeech
       end
 
       it 'registers itself' do
-        Element.class_from_registration(:break).should == Break
+        expect(Element.class_from_registration(:break)).to eq(Break)
       end
 
       describe "from a document" do
-        let(:document) { '<break strength="strong" time="3"/>' }
-
         subject { Element.import document }
 
-        it { should be_instance_of Break }
+        context 'with time of 3' do
+          let(:document) { '<break strength="strong" time="3"/>' }
 
-        its(:strength)  { should == :strong }
-        its(:time)      { should == 3 }
+          it { is_expected.to be_instance_of Break }
+
+          its(:strength)  { should == :strong }
+          its(:time)      { should eql 3.0 }
+        end
+
+        context 'with time of 4s' do
+          let(:document) { '<break time="4s"/>' }
+
+          its(:time)      { should eql 4.0 }
+        end
+
+        context 'with time of 5555ms' do
+          let(:document) { '<break time="5555ms"/>' }
+
+          its(:time)      { should eql 5.555 }
+        end
       end
 
       describe "#strength" do
@@ -37,65 +51,71 @@ module RubySpeech
         its(:strength) { should == :strong }
 
         it "with a valid level" do
-          lambda { subject.strength = :none }.should_not raise_error
-          lambda { subject.strength = :'x-weak' }.should_not raise_error
-          lambda { subject.strength = :weak }.should_not raise_error
-          lambda { subject.strength = :medium }.should_not raise_error
-          lambda { subject.strength = :strong }.should_not raise_error
-          lambda { subject.strength = :'x-strong' }.should_not raise_error
+          expect { subject.strength = :none }.not_to raise_error
+          expect { subject.strength = :'x-weak' }.not_to raise_error
+          expect { subject.strength = :weak }.not_to raise_error
+          expect { subject.strength = :medium }.not_to raise_error
+          expect { subject.strength = :strong }.not_to raise_error
+          expect { subject.strength = :'x-strong' }.not_to raise_error
         end
 
         it "with an invalid strength" do
-          lambda { subject.strength = :something }.should raise_error(ArgumentError, "You must specify a valid strength (:none, :\"x-weak\", :weak, :medium, :strong, :\"x-strong\")")
+          expect { subject.strength = :something }.to raise_error(ArgumentError, "You must specify a valid strength (:none, :\"x-weak\", :weak, :medium, :strong, :\"x-strong\")")
         end
       end
 
       describe "#time" do
-        context "with a valid value" do
+        context "with a valid whole seconds value of 3" do
           before { subject.time = 3 }
 
-          its(:time) { should == 3 }
+          its(:time) { should eql 3.0 }
+        end
+
+        context "with a valid fractional seconds value of 3.5" do
+          before { subject.time = 3.5 }
+
+          its(:time) { should eql 3.5 }
         end
 
         context "with a negative value" do
           it do
-            lambda { subject.time = -3 }.should raise_error(ArgumentError, "You must specify a valid time (positive float value in seconds)")
+            expect { subject.time = -3 }.to raise_error(ArgumentError, "You must specify a valid time (positive float value in seconds)")
           end
         end
 
         context "with an invalid value" do
           it do
-            lambda { subject.time = 'blah' }.should raise_error(ArgumentError, "You must specify a valid time (positive float value in seconds)")
+            expect { subject.time = 'blah' }.to raise_error(ArgumentError, "You must specify a valid time (positive float value in seconds)")
           end
         end
       end
 
       describe "<<" do
         it "should always raise InvalidChildError" do
-          lambda { subject << 'anything' }.should raise_error(InvalidChildError, "A Break cannot contain children")
+          expect { subject << 'anything' }.to raise_error(InvalidChildError, "A Break cannot contain children")
         end
       end
 
       describe "comparing objects" do
         it "should be equal if the content, strength and base uri are the same" do
-          Break.new(doc, :strength => :strong, :time => 1, :content => "Hello there").should == Break.new(doc, :strength => :strong, :time => 1, :content => "Hello there")
+          expect(Break.new(doc, :strength => :strong, :time => 1, :content => "Hello there")).to eq(Break.new(doc, :strength => :strong, :time => 1, :content => "Hello there"))
         end
 
         describe "when the content is different" do
           it "should not be equal" do
-            Break.new(doc, :content => "Hello").should_not == Break.new(doc, :content => "Hello there")
+            expect(Break.new(doc, :content => "Hello")).not_to eq(Break.new(doc, :content => "Hello there"))
           end
         end
 
         describe "when the strength is different" do
           it "should not be equal" do
-            Break.new(doc, :strength => :strong).should_not == Break.new(doc, :strength => :weak)
+            expect(Break.new(doc, :strength => :strong)).not_to eq(Break.new(doc, :strength => :weak))
           end
         end
 
         describe "when the time is different" do
           it "should not be equal" do
-            Break.new(doc, :time => 1).should_not == Break.new(doc, :time => 2)
+            expect(Break.new(doc, :time => 1)).not_to eq(Break.new(doc, :time => 2))
           end
         end
       end

data/spec/ruby_speech/ssml/desc_spec.rb

@@ -16,7 +16,7 @@ module RubySpeech
       end
 
       it 'registers itself' do
-        Element.class_from_registration(:desc).should == Desc
+        expect(Element.class_from_registration(:desc)).to eq(Desc)
       end
 
       describe "from a document" do
@@ -24,36 +24,36 @@ module RubySpeech
 
         subject { Element.import document }
 
-        it { should be_instance_of Desc }
+        it { is_expected.to be_instance_of Desc }
 
         its(:language) { should == 'en' }
       end
 
       describe "comparing objects" do
         it "should be equal if the content and language are the same" do
-          Desc.new(doc, :language => 'jp', :content => "Hello there").should == Desc.new(doc, :language => 'jp', :content => "Hello there")
+          expect(Desc.new(doc, :language => 'jp', :content => "Hello there")).to eq(Desc.new(doc, :language => 'jp', :content => "Hello there"))
         end
 
         describe "when the content is different" do
           it "should not be equal" do
-            Desc.new(doc, :content => "Hello").should_not == Desc.new(doc, :content => "Hello there")
+            expect(Desc.new(doc, :content => "Hello")).not_to eq(Desc.new(doc, :content => "Hello there"))
           end
         end
 
         describe "when the language is different" do
           it "should not be equal" do
-            Desc.new(doc, :language => 'jp').should_not == Desc.new(doc, :language => 'en')
+            expect(Desc.new(doc, :language => 'jp')).not_to eq(Desc.new(doc, :language => 'en'))
           end
         end
       end
 
       describe "<<" do
         it "should accept String" do
-          lambda { subject << 'anything' }.should_not raise_error
+          expect { subject << 'anything' }.not_to raise_error
         end
 
         it "should raise InvalidChildError with non-acceptable objects" do
-          lambda { subject << Voice.new(doc) }.should raise_error(InvalidChildError, "A Desc can only accept Strings as children")
+          expect { subject << Voice.new(doc) }.to raise_error(InvalidChildError, "A Desc can only accept Strings as children")
         end
       end
     end # Desc

data/spec/ruby_speech/ssml/emphasis_spec.rb

@@ -16,7 +16,7 @@ module RubySpeech
       end
 
       it 'registers itself' do
-        Element.class_from_registration(:emphasis).should == Emphasis
+        expect(Element.class_from_registration(:emphasis)).to eq(Emphasis)
       end
 
       describe "from a document" do
@@ -24,7 +24,7 @@ module RubySpeech
 
         subject { Element.import document }
 
-        it { should be_instance_of Emphasis }
+        it { is_expected.to be_instance_of Emphasis }
 
         its(:level) { should == :strong }
       end
@@ -35,78 +35,78 @@ module RubySpeech
         its(:level) { should == :strong }
 
         it "with a valid level" do
-          lambda { subject.level = :strong }.should_not raise_error
-          lambda { subject.level = :moderate }.should_not raise_error
-          lambda { subject.level = :none }.should_not raise_error
-          lambda { subject.level = :reduced }.should_not raise_error
+          expect { subject.level = :strong }.not_to raise_error
+          expect { subject.level = :moderate }.not_to raise_error
+          expect { subject.level = :none }.not_to raise_error
+          expect { subject.level = :reduced }.not_to raise_error
         end
 
         it "with an invalid level" do
-          lambda { subject.level = :something }.should raise_error(ArgumentError, "You must specify a valid level (:strong, :moderate, :none, :reduced)")
+          expect { subject.level = :something }.to raise_error(ArgumentError, "You must specify a valid level (:strong, :moderate, :none, :reduced)")
         end
       end
 
       describe "comparing objects" do
         it "should be equal if the content and level are the same" do
-          Emphasis.new(doc, :level => :strong, :content => "Hello there").should == Emphasis.new(doc, :level => :strong, :content => "Hello there")
+          expect(Emphasis.new(doc, :level => :strong, :content => "Hello there")).to eq(Emphasis.new(doc, :level => :strong, :content => "Hello there"))
         end
 
         describe "when the content is different" do
           it "should not be equal" do
-            Emphasis.new(doc, :content => "Hello").should_not == Emphasis.new(doc, :content => "Hello there")
+            expect(Emphasis.new(doc, :content => "Hello")).not_to eq(Emphasis.new(doc, :content => "Hello there"))
           end
         end
 
         describe "when the level is different" do
           it "should not be equal" do
-            Emphasis.new(doc, :level => :strong).should_not == Emphasis.new(doc, :level => :reduced)
+            expect(Emphasis.new(doc, :level => :strong)).not_to eq(Emphasis.new(doc, :level => :reduced))
           end
         end
       end
 
       describe "<<" do
         it "should accept String" do
-          lambda { subject << 'anything' }.should_not raise_error
+          expect { subject << 'anything' }.not_to raise_error
         end
 
         it "should accept Audio" do
-          lambda { subject << Audio.new(doc) }.should_not raise_error
+          expect { subject << Audio.new(doc) }.not_to raise_error
         end
 
         it "should accept Break" do
-          lambda { subject << Break.new(doc) }.should_not raise_error
+          expect { subject << Break.new(doc) }.not_to raise_error
         end
 
         it "should accept Emphasis" do
-          lambda { subject << Emphasis.new(doc) }.should_not raise_error
+          expect { subject << Emphasis.new(doc) }.not_to raise_error
         end
 
         it "should accept Mark" do
-          lambda { subject << Mark.new(doc) }.should_not raise_error
+          expect { subject << Mark.new(doc) }.not_to raise_error
         end
 
         it "should accept Phoneme" do
-          lambda { subject << Phoneme.new(doc) }.should_not raise_error
+          expect { subject << Phoneme.new(doc) }.not_to raise_error
         end
 
         it "should accept Prosody" do
-          lambda { subject << Prosody.new(doc) }.should_not raise_error
+          expect { subject << Prosody.new(doc) }.not_to raise_error
         end
 
         it "should accept SayAs" do
-          lambda { subject << SayAs.new(doc, :interpret_as => :foo) }.should_not raise_error
+          expect { subject << SayAs.new(doc, :interpret_as => :foo) }.not_to raise_error
         end
 
         it "should accept Sub" do
-          lambda { subject << Sub.new(doc) }.should_not raise_error
+          expect { subject << Sub.new(doc) }.not_to raise_error
         end
 
         it "should accept Voice" do
-          lambda { subject << Voice.new(doc) }.should_not raise_error
+          expect { subject << Voice.new(doc) }.not_to raise_error
         end
 
         it "should raise InvalidChildError with non-acceptable objects" do
-          lambda { subject << 1 }.should raise_error(InvalidChildError, "An Emphasis can only accept String, Audio, Break, Emphasis, Mark, Phoneme, Prosody, SayAs, Sub, Voice as children")
+          expect { subject << 1 }.to raise_error(InvalidChildError, "An Emphasis can only accept String, Audio, Break, Emphasis, Mark, Phoneme, Prosody, SayAs, Sub, Voice as children")
         end
       end
     end # Emphasis

data/spec/ruby_speech/ssml/mark_spec.rb

@@ -16,7 +16,7 @@ module RubySpeech
       end
 
       it 'registers itself' do
-        Element.class_from_registration(:mark).should == Mark
+        expect(Element.class_from_registration(:mark)).to eq(Mark)
       end
 
       describe "from a document" do
@@ -24,7 +24,7 @@ module RubySpeech
 
         subject { Element.import document }
 
-        it { should be_instance_of Mark }
+        it { is_expected.to be_instance_of Mark }
 
         its(:name)  { should == 'foo' }
       end
@@ -37,18 +37,18 @@ module RubySpeech
 
       describe "<<" do
         it "should always raise InvalidChildError" do
-          lambda { subject << 'anything' }.should raise_error(InvalidChildError, "A Mark cannot contain children")
+          expect { subject << 'anything' }.to raise_error(InvalidChildError, "A Mark cannot contain children")
         end
       end
 
       describe "comparing objects" do
         it "should be equal if the name is the same" do
-          Mark.new(doc, :name => "foo").should == Mark.new(doc, :name => "foo")
+          expect(Mark.new(doc, :name => "foo")).to eq(Mark.new(doc, :name => "foo"))
         end
 
         describe "when the name is different" do
           it "should not be equal" do
-            Mark.new(doc, :name => "foo").should_not == Mark.new(doc, :name => "bar")
+            expect(Mark.new(doc, :name => "foo")).not_to eq(Mark.new(doc, :name => "bar"))
           end
         end
       end

data/spec/ruby_speech/ssml/p_spec.rb

@@ -16,7 +16,7 @@ module RubySpeech
       end
 
       it 'registers itself' do
-        Element.class_from_registration(:p).should == P
+        expect(Element.class_from_registration(:p)).to eq(P)
       end
 
       describe "from a document" do
@@ -24,75 +24,75 @@ module RubySpeech
 
         subject { Element.import document }
 
-        it { should be_instance_of P }
+        it { is_expected.to be_instance_of P }
         its(:content) { should == 'foo' }
       end
 
       describe "comparing objects" do
         it "should be equal if the content and language are the same" do
-          P.new(doc, :language => 'jp', :content => "Hello there").should == P.new(doc, :language => 'jp', :content => "Hello there")
+          expect(P.new(doc, :language => 'jp', :content => "Hello there")).to eq(P.new(doc, :language => 'jp', :content => "Hello there"))
         end
 
         describe "when the content is different" do
           it "should not be equal" do
-            P.new(doc, :content => "Hello").should_not == P.new(doc, :content => "Hello there")
+            expect(P.new(doc, :content => "Hello")).not_to eq(P.new(doc, :content => "Hello there"))
           end
         end
 
         describe "when the language is different" do
           it "should not be equal" do
-            P.new(doc, :language => 'jp').should_not == P.new(doc, :language => 'en')
+            expect(P.new(doc, :language => 'jp')).not_to eq(P.new(doc, :language => 'en'))
           end
         end
       end
 
       describe "<<" do
         it "should accept String" do
-          lambda { subject << 'anything' }.should_not raise_error
+          expect { subject << 'anything' }.not_to raise_error
         end
 
         it "should accept Audio" do
-          lambda { subject << Audio.new(doc) }.should_not raise_error
+          expect { subject << Audio.new(doc) }.not_to raise_error
         end
 
         it "should accept Break" do
-          lambda { subject << Break.new(doc) }.should_not raise_error
+          expect { subject << Break.new(doc) }.not_to raise_error
         end
 
         it "should accept Emphasis" do
-          lambda { subject << Emphasis.new(doc) }.should_not raise_error
+          expect { subject << Emphasis.new(doc) }.not_to raise_error
         end
 
         it "should accept Mark" do
-          lambda { subject << Mark.new(doc) }.should_not raise_error
+          expect { subject << Mark.new(doc) }.not_to raise_error
         end
 
         it "should accept Phoneme" do
-          lambda { subject << Phoneme.new(doc) }.should_not raise_error
+          expect { subject << Phoneme.new(doc) }.not_to raise_error
         end
 
         it "should accept Prosody" do
-          lambda { subject << Prosody.new(doc) }.should_not raise_error
+          expect { subject << Prosody.new(doc) }.not_to raise_error
         end
 
         it "should accept SayAs" do
-          lambda { subject << SayAs.new(doc, :interpret_as => :foo) }.should_not raise_error
+          expect { subject << SayAs.new(doc, :interpret_as => :foo) }.not_to raise_error
         end
 
         it "should accept Sub" do
-          lambda { subject << Sub.new(doc) }.should_not raise_error
+          expect { subject << Sub.new(doc) }.not_to raise_error
         end
 
         it "should accept S" do
-          lambda { subject << S.new(doc) }.should_not raise_error
+          expect { subject << S.new(doc) }.not_to raise_error
         end
 
         it "should accept Voice" do
-          lambda { subject << Voice.new(doc) }.should_not raise_error
+          expect { subject << Voice.new(doc) }.not_to raise_error
         end
 
         it "should raise InvalidChildError with non-acceptable objects" do
-          lambda { subject << 1 }.should raise_error(InvalidChildError, "A P can only accept String, Audio, Break, Emphasis, Mark, Phoneme, Prosody, SayAs, Sub, S, Voice as children")
+          expect { subject << 1 }.to raise_error(InvalidChildError, "A P can only accept String, Audio, Break, Emphasis, Mark, Phoneme, Prosody, SayAs, Sub, S, Voice as children")
         end
       end
     end # P

data/spec/ruby_speech/ssml/phoneme_spec.rb

@@ -17,7 +17,7 @@ module RubySpeech
       end
 
       it 'registers itself' do
-        Element.class_from_registration(:phoneme).should == Phoneme
+        expect(Element.class_from_registration(:phoneme)).to eq(Phoneme)
       end
 
       describe "from a document" do
@@ -25,7 +25,7 @@ module RubySpeech
 
         subject { Element.import document }
 
-        it { should be_instance_of Phoneme }
+        it { is_expected.to be_instance_of Phoneme }
 
         its(:alphabet) { should == 'foo' }
         its(:ph)       { should == 'bar' }
@@ -33,35 +33,35 @@ module RubySpeech
 
       describe "comparing objects" do
         it "should be equal if the content, ph and alphabet are the same" do
-          Phoneme.new(doc, :alphabet => 'jp', :ph => 'foo', :content => "Hello there").should == Phoneme.new(doc, :alphabet => 'jp', :ph => 'foo', :content => "Hello there")
+          expect(Phoneme.new(doc, :alphabet => 'jp', :ph => 'foo', :content => "Hello there")).to eq(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(doc, :content => "Hello").should_not == Phoneme.new(doc, :content => "Hello there")
+            expect(Phoneme.new(doc, :content => "Hello")).not_to eq(Phoneme.new(doc, :content => "Hello there"))
           end
         end
 
         describe "when the ph is different" do
           it "should not be equal" do
-            Phoneme.new(doc, :ph => 'jp').should_not == Phoneme.new(doc, :ph => 'en')
+            expect(Phoneme.new(doc, :ph => 'jp')).not_to eq(Phoneme.new(doc, :ph => 'en'))
           end
         end
 
         describe "when the alphabet is different" do
           it "should not be equal" do
-            Phoneme.new(doc, :alphabet => 'jp').should_not == Phoneme.new(doc, :alphabet => 'en')
+            expect(Phoneme.new(doc, :alphabet => 'jp')).not_to eq(Phoneme.new(doc, :alphabet => 'en'))
           end
         end
       end
 
       describe "<<" do
         it "should accept String" do
-          lambda { subject << 'anything' }.should_not raise_error
+          expect { subject << 'anything' }.not_to raise_error
         end
 
         it "should raise InvalidChildError with non-acceptable objects" do
-          lambda { subject << Voice.new(doc) }.should raise_error(InvalidChildError, "A Phoneme can only accept Strings as children")
+          expect { subject << Voice.new(doc) }.to raise_error(InvalidChildError, "A Phoneme can only accept Strings as children")
         end
       end
     end # Desc