ruby_speech 2.4.0-java → 3.0.0-java

data/spec/ruby_speech/ssml/s_spec.rb

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

data/spec/ruby_speech/ssml/say_as_spec.rb

@@ -16,7 +16,7 @@ module RubySpeech
       its(:detail)       { should == 'three' }
 
       it 'registers itself' do
-        Element.class_from_registration(:'say-as').should == SayAs
+        expect(Element.class_from_registration(:'say-as')).to eq(SayAs)
       end
 
       describe "from a document" do
@@ -24,7 +24,7 @@ module RubySpeech
 
         subject { Element.import document }
 
-        it { should be_instance_of SayAs }
+        it { is_expected.to be_instance_of SayAs }
 
         its(:interpret_as) { should == 'one' }
         its(:format)       { should == 'two' }
@@ -33,41 +33,41 @@ 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(doc, :interpret_as => 'jp', :format => 'foo', :detail => 'bar', :content => "hello").should == SayAs.new(doc, :interpret_as => 'jp', :format => 'foo', :detail => 'bar', :content => "hello")
+          expect(SayAs.new(doc, :interpret_as => 'jp', :format => 'foo', :detail => 'bar', :content => "hello")).to eq(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(doc, :interpret_as => 'jp', :content => "Hello").should_not == SayAs.new(doc, :interpret_as => 'jp', :content => "Hello there")
+            expect(SayAs.new(doc, :interpret_as => 'jp', :content => "Hello")).not_to eq(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(doc, :interpret_as => "Hello").should_not == SayAs.new(doc, :interpret_as => "Hello there")
+            expect(SayAs.new(doc, :interpret_as => "Hello")).not_to eq(SayAs.new(doc, :interpret_as => "Hello there"))
           end
         end
 
         describe "when the format is different" do
           it "should not be equal" do
-            SayAs.new(doc, :interpret_as => 'jp', :format => 'foo').should_not == SayAs.new(doc, :interpret_as => 'jp', :format => 'bar')
+            expect(SayAs.new(doc, :interpret_as => 'jp', :format => 'foo')).not_to eq(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(doc, :interpret_as => 'jp', :detail => 'foo').should_not == SayAs.new(doc, :interpret_as => 'jp', :detail => 'bar')
+            expect(SayAs.new(doc, :interpret_as => 'jp', :detail => 'foo')).not_to eq(SayAs.new(doc, :interpret_as => 'jp', :detail => 'bar'))
           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 SayAs can only accept Strings as children")
+          expect { subject << Voice.new(doc) }.to raise_error(InvalidChildError, "A SayAs can only accept Strings as children")
         end
       end
     end # SayAs

data/spec/ruby_speech/ssml/speak_spec.rb

@@ -7,7 +7,7 @@ module RubySpeech
 
       subject { described_class.new doc }
 
-      it { should be_a_valid_ssml_document }
+      it { is_expected.to be_a_valid_ssml_document }
 
       its(:name) { should == 'speak' }
       its(:language) { should == 'en-US' }
@@ -20,7 +20,7 @@ module RubySpeech
       end
 
       it 'registers itself' do
-        Element.class_from_registration(:speak).should == Speak
+        expect(Element.class_from_registration(:speak)).to eq(Speak)
       end
 
       describe "from a document" do
@@ -28,7 +28,7 @@ module RubySpeech
 
         subject { Element.import document }
 
-        it { should be_instance_of Speak }
+        it { is_expected.to be_instance_of Speak }
 
         its(:language) { should == 'jp' }
         its(:base_uri) { should == 'blah' }
@@ -48,24 +48,24 @@ module RubySpeech
 
       describe "comparing objects" do
         it "should be equal if the content, language and base uri are the same" do
-          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")
+          expect(Speak.new(doc, :language => 'en-GB', :base_uri => 'blah', :content => "Hello there")).to eq(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(doc, :content => "Hello").should_not == Speak.new(doc, :content => "Hello there")
+            expect(Speak.new(doc, :content => "Hello")).not_to eq(Speak.new(doc, :content => "Hello there"))
           end
         end
 
         describe "when the language is different" do
           it "should not be equal" do
-            Speak.new(doc, :language => 'en-US').should_not == Speak.new(doc, :language => 'en-GB')
+            expect(Speak.new(doc, :language => 'en-US')).not_to eq(Speak.new(doc, :language => 'en-GB'))
           end
         end
 
         describe "when the base URI is different" do
           it "should not be equal" do
-            Speak.new(doc, :base_uri => 'foo').should_not == Speak.new(doc, :base_uri => 'bar')
+            expect(Speak.new(doc, :base_uri => 'foo')).not_to eq(Speak.new(doc, :base_uri => 'bar'))
           end
         end
 
@@ -76,7 +76,7 @@ module RubySpeech
             s2 = Speak.new doc
             s2 << SayAs.new(doc, :interpret_as => 'time')
 
-            s1.should_not == s2
+            expect(s1).not_to eq(s2)
           end
         end
       end
@@ -86,66 +86,66 @@ module RubySpeech
         s.voice :gender => :male, :content => 'Hello'
         expected_s = Speak.new doc
         expected_s << Voice.new(doc, :gender => :male, :content => 'Hello')
-        s.should == expected_s
+        expect(s).to eq(expected_s)
       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 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, "A Speak can only accept String, Audio, Break, Emphasis, Mark, P, Phoneme, Prosody, SayAs, Sub, S, Voice as children")
+          expect { subject << 1 }.to raise_error(InvalidChildError, "A Speak can only accept String, Audio, Break, Emphasis, Mark, P, Phoneme, Prosody, SayAs, Sub, S, Voice as children")
         end
       end
 
       describe "#to_doc" do
         it "should create an XML document from the grammar" do
-          subject.to_doc.should == subject.document
+          expect(subject.to_doc).to eq(subject.document)
         end
       end
 
@@ -176,11 +176,11 @@ module RubySpeech
         end
 
         concat = (speak1 + speak2)
-        speak1.to_s.should == speak1_string
-        speak2.to_s.should == speak2_string
-        concat.should == expected_concat
-        concat.document.root.should == concat
-        concat.to_s.should_not include('default')
+        expect(speak1.to_s).to eq(speak1_string)
+        expect(speak2.to_s).to eq(speak2_string)
+        expect(concat).to eq(expected_concat)
+        expect(concat.document.root).to eq(concat)
+        expect(concat.to_s).not_to include('default')
       end
 
       context "when concatenating" do
@@ -199,7 +199,7 @@ module RubySpeech
             end
 
             concat = (speak1 + speak2)
-            concat.should == expected_concat
+            expect(concat).to eq(expected_concat)
           end
         end
       end

data/spec/ruby_speech/ssml/sub_spec.rb

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

data/spec/ruby_speech/ssml/voice_spec.rb

@@ -21,7 +21,7 @@ module RubySpeech
       end
 
       it 'registers itself' do
-        Element.class_from_registration(:voice).should == Voice
+        expect(Element.class_from_registration(:voice)).to eq(Voice)
       end
 
       describe "from a document" do
@@ -29,7 +29,7 @@ module RubySpeech
 
         subject { Element.import document }
 
-        it { should be_instance_of Voice }
+        it { is_expected.to be_instance_of Voice }
 
         its(:language)  { should == 'jp' }
         its(:gender)    { should == :male }
@@ -50,13 +50,13 @@ module RubySpeech
         its(:gender) { should == :male }
 
         it "with a valid gender" do
-          lambda { subject.gender = :male }.should_not raise_error
-          lambda { subject.gender = :female }.should_not raise_error
-          lambda { subject.gender = :neutral }.should_not raise_error
+          expect { subject.gender = :male }.not_to raise_error
+          expect { subject.gender = :female }.not_to raise_error
+          expect { subject.gender = :neutral }.not_to raise_error
         end
 
         it "with an invalid gender" do
-          lambda { subject.gender = :something }.should raise_error(ArgumentError, "You must specify a valid gender (:male, :female, :neutral)")
+          expect { subject.gender = :something }.to raise_error(ArgumentError, "You must specify a valid gender (:male, :female, :neutral)")
         end
       end
 
@@ -66,15 +66,15 @@ module RubySpeech
         its(:age) { should == 12 }
 
         it "with an integer of 0" do
-          lambda { subject.age = 0 }.should_not raise_error
+          expect { subject.age = 0 }.not_to raise_error
         end
 
         it "with an integer less than 0" do
-          lambda { subject.age = -1 }.should raise_error(ArgumentError, "You must specify a valid age (non-negative integer)")
+          expect { subject.age = -1 }.to raise_error(ArgumentError, "You must specify a valid age (non-negative integer)")
         end
 
         it "with something other than an integer" do
-          lambda { subject.age = "bah" }.should raise_error(ArgumentError, "You must specify a valid age (non-negative integer)")
+          expect { subject.age = "bah" }.to raise_error(ArgumentError, "You must specify a valid age (non-negative integer)")
         end
       end
 
@@ -84,11 +84,11 @@ module RubySpeech
         its(:variant) { should == 12 }
 
         it "with an integer less than 1" do
-          lambda { subject.variant = 0 }.should raise_error(ArgumentError, "You must specify a valid variant (positive integer)")
+          expect { subject.variant = 0 }.to raise_error(ArgumentError, "You must specify a valid variant (positive integer)")
         end
 
         it "with something other than an integer" do
-          lambda { subject.variant = "bah" }.should raise_error(ArgumentError, "You must specify a valid variant (positive integer)")
+          expect { subject.variant = "bah" }.to raise_error(ArgumentError, "You must specify a valid variant (positive integer)")
         end
       end
 
@@ -106,97 +106,97 @@ module RubySpeech
 
       describe "comparing objects" do
         it "should be equal if the content, language, gender, age, variant, name are the same" do
-          Voice.new(doc, :language => 'jp', :gender => :male, :age => 25, :variant => 2, :name => "paul", :content => "hello").should == Voice.new(doc, :language => 'jp', :gender => :male, :age => 25, :variant => 2, :name => "paul", :content => "hello")
+          expect(Voice.new(doc, :language => 'jp', :gender => :male, :age => 25, :variant => 2, :name => "paul", :content => "hello")).to eq(Voice.new(doc, :language => 'jp', :gender => :male, :age => 25, :variant => 2, :name => "paul", :content => "hello"))
         end
 
         describe "when the content is different" do
           it "should not be equal" do
-            Voice.new(doc, :content => "Hello").should_not == Voice.new(doc, :content => "Hello there")
+            expect(Voice.new(doc, :content => "Hello")).not_to eq(Voice.new(doc, :content => "Hello there"))
           end
         end
 
         describe "when the language is different" do
           it "should not be equal" do
-            Voice.new(doc, :language => "Hello").should_not == Voice.new(doc, :language => "Hello there")
+            expect(Voice.new(doc, :language => "Hello")).not_to eq(Voice.new(doc, :language => "Hello there"))
           end
         end
 
         describe "when the gender is different" do
           it "should not be equal" do
-            Voice.new(doc, :gender => :male).should_not == Voice.new(doc, :gender => :female)
+            expect(Voice.new(doc, :gender => :male)).not_to eq(Voice.new(doc, :gender => :female))
           end
         end
 
         describe "when the age is different" do
           it "should not be equal" do
-            Voice.new(doc, :age => 20).should_not == Voice.new(doc, :age => 30)
+            expect(Voice.new(doc, :age => 20)).not_to eq(Voice.new(doc, :age => 30))
           end
         end
 
         describe "when the variant is different" do
           it "should not be equal" do
-            Voice.new(doc, :variant => 1).should_not == Voice.new(doc, :variant => 2)
+            expect(Voice.new(doc, :variant => 1)).not_to eq(Voice.new(doc, :variant => 2))
           end
         end
 
         describe "when the name is different" do
           it "should not be equal" do
-            Voice.new(doc, :name => "Hello").should_not == Voice.new(doc, :name => "Hello there")
+            expect(Voice.new(doc, :name => "Hello")).not_to eq(Voice.new(doc, :name => "Hello there"))
           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 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, "A Voice can only accept String, Audio, Break, Emphasis, Mark, P, Phoneme, Prosody, SayAs, Sub, S, Voice as children")
+          expect { subject << 1 }.to raise_error(InvalidChildError, "A Voice can only accept String, Audio, Break, Emphasis, Mark, P, Phoneme, Prosody, SayAs, Sub, S, Voice as children")
         end
       end
     end # Voice