ruby_speech 2.3.1-java → 3.0.1-java

data/spec/ruby_speech/grxml/item_spec.rb

@@ -13,7 +13,7 @@ module RubySpeech
       its(:repeat)  { should == 1 }
 
       it 'registers itself' do
-        Element.class_from_registration(:item).should == Item
+        expect(Element.class_from_registration(:item)).to eq(Item)
       end
 
       describe "everything from a document" do
@@ -21,7 +21,7 @@ module RubySpeech
 
         subject { Element.import document }
 
-        it { should be_instance_of Item }
+        it { is_expected.to be_instance_of Item }
 
         its(:weight)  { should == 1.1 }
         its(:repeat)  { should == 1 }
@@ -54,16 +54,16 @@ module RubySpeech
           its(:weight) { should == 1.1 }
 
           it "with valid value" do
-            lambda { subject.weight = 1 }.should_not raise_error
-            lambda { subject.weight = 1.0 }.should_not raise_error
-            lambda { subject.weight = 0.1 }.should_not raise_error
-            lambda { subject.weight = '.1' }.should_not raise_error
-            lambda { subject.weight = '1.' }.should_not raise_error
+            expect { subject.weight = 1 }.not_to raise_error
+            expect { subject.weight = 1.0 }.not_to raise_error
+            expect { subject.weight = 0.1 }.not_to raise_error
+            expect { subject.weight = '.1' }.not_to raise_error
+            expect { subject.weight = '1.' }.not_to raise_error
           end
 
           it "with an invalid value" do
-            lambda { subject.weight = 'one' }.should raise_error(ArgumentError, "A Item's weight attribute must be a positive floating point number")
-            lambda { subject.weight = -1 }.should raise_error(ArgumentError, "A Item's weight attribute must be a positive floating point number")
+            expect { subject.weight = 'one' }.to raise_error(ArgumentError, "A Item's weight attribute must be a positive floating point number")
+            expect { subject.weight = -1 }.to raise_error(ArgumentError, "A Item's weight attribute must be a positive floating point number")
           end
         end
       end
@@ -87,8 +87,8 @@ module RubySpeech
           end
 
           it "invalid values" do
-            lambda { subject.repeat = -1 }.should raise_error(ArgumentError, "A Item's repeat must be 0 or a positive integer")
-            lambda { subject.repeat = 'one' }.should raise_error(ArgumentError, "A Item's repeat must be 0 or a positive integer")
+            expect { subject.repeat = -1 }.to raise_error(ArgumentError, "A Item's repeat must be 0 or a positive integer")
+            expect { subject.repeat = 'one' }.to raise_error(ArgumentError, "A Item's repeat must be 0 or a positive integer")
           end
         end
 
@@ -111,12 +111,12 @@ module RubySpeech
           end
 
           it "illegal ranges from m to n" do
-            lambda { subject.repeat = '5-1' }.should raise_error(ArgumentError, "A Item's repeat must be 0 or a positive integer")
-            lambda { subject.repeat = '-1-2' }.should raise_error(ArgumentError, "A Item's repeat must be 0 or a positive integer")
-            lambda { subject.repeat = '1-2-3' }.should raise_error(ArgumentError, "A Item's repeat must be 0 or a positive integer")
-            lambda { subject.repeat = '1-B' }.should raise_error(ArgumentError, "A Item's repeat must be 0 or a positive integer")
-            lambda { subject.repeat = -1..2 }.should raise_error(ArgumentError, "A Item's repeat must be 0 or a positive integer")
-            lambda { subject.repeat = 1..-2 }.should raise_error(ArgumentError, "A Item's repeat must be 0 or a positive integer")
+            expect { subject.repeat = '5-1' }.to raise_error(ArgumentError, "A Item's repeat must be 0 or a positive integer")
+            expect { subject.repeat = '-1-2' }.to raise_error(ArgumentError, "A Item's repeat must be 0 or a positive integer")
+            expect { subject.repeat = '1-2-3' }.to raise_error(ArgumentError, "A Item's repeat must be 0 or a positive integer")
+            expect { subject.repeat = '1-B' }.to raise_error(ArgumentError, "A Item's repeat must be 0 or a positive integer")
+            expect { subject.repeat = -1..2 }.to raise_error(ArgumentError, "A Item's repeat must be 0 or a positive integer")
+            expect { subject.repeat = 1..-2 }.to raise_error(ArgumentError, "A Item's repeat must be 0 or a positive integer")
           end
 
           context "valid ranges of m or more" do
@@ -134,8 +134,8 @@ module RubySpeech
           end
 
           it "illegal ranges for m or more" do
-            lambda { subject.repeat = '-1-' }.should raise_error(ArgumentError, "A Item's repeat must be 0 or a positive integer")
-            lambda { subject.repeat = 'B-' }.should raise_error(ArgumentError, "A Item's repeat must be 0 or a positive integer")
+            expect { subject.repeat = '-1-' }.to raise_error(ArgumentError, "A Item's repeat must be 0 or a positive integer")
+            expect { subject.repeat = 'B-' }.to raise_error(ArgumentError, "A Item's repeat must be 0 or a positive integer")
           end
         end
       end
@@ -143,17 +143,17 @@ module RubySpeech
       # repeat probability (repeat-prob) -- http://www.w3.org/TR/speech-grammar/#S2.5.1
       describe "#repeat_prob" do
         it "should handle all valid values" do
-          lambda { subject.repeat_prob = 0 }.should_not raise_error
-          lambda { subject.repeat_prob = 1 }.should_not raise_error
-          lambda { subject.repeat_prob = 1.0 }.should_not raise_error
-          lambda { subject.repeat_prob = '1.' }.should_not raise_error
-          lambda { subject.repeat_prob = '1.0' }.should_not raise_error
-          lambda { subject.repeat_prob = '.5' }.should_not raise_error
+          expect { subject.repeat_prob = 0 }.not_to raise_error
+          expect { subject.repeat_prob = 1 }.not_to raise_error
+          expect { subject.repeat_prob = 1.0 }.not_to raise_error
+          expect { subject.repeat_prob = '1.' }.not_to raise_error
+          expect { subject.repeat_prob = '1.0' }.not_to raise_error
+          expect { subject.repeat_prob = '.5' }.not_to raise_error
         end
 
         it "should raise an error for invalid values" do
-          lambda { subject.repeat_prob = -1 }.should raise_error(ArgumentError, "A Item's repeat probablity attribute must be a floating point number between 0.0 and 1.0")
-          lambda { subject.repeat_prob = 1.5 }.should raise_error(ArgumentError, "A Item's repeat probablity attribute must be a floating point number between 0.0 and 1.0")
+          expect { subject.repeat_prob = -1 }.to raise_error(ArgumentError, "A Item's repeat probablity attribute must be a floating point number between 0.0 and 1.0")
+          expect { subject.repeat_prob = 1.5 }.to raise_error(ArgumentError, "A Item's repeat probablity attribute must be a floating point number between 0.0 and 1.0")
         end
       end
 
@@ -166,27 +166,27 @@ 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 OneOf" do
-          lambda { subject << OneOf.new(doc) }.should_not raise_error
+          expect { subject << OneOf.new(doc) }.not_to raise_error
         end
 
         it "should accept Item" do
-          lambda { subject << Item.new(doc) }.should_not raise_error
+          expect { subject << Item.new(doc) }.not_to raise_error
         end
 
         it "should accept Ruleref" do
-          lambda { subject << Ruleref.new(doc) }.should_not raise_error
+          expect { subject << Ruleref.new(doc) }.not_to raise_error
         end
 
         it "should accept Tag" do
-          lambda { subject << Tag.new(doc) }.should_not raise_error
+          expect { subject << Tag.new(doc) }.not_to raise_error
         end
 
         it "should accept Token" do
-          lambda { subject << Token.new(doc) }.should_not raise_error
+          expect { subject << Token.new(doc) }.not_to raise_error
         end
       end
     end # Item

data/spec/ruby_speech/grxml/match_spec.rb

@@ -7,7 +7,7 @@ module RubySpeech
 
       describe "equality" do
         it "should never be equal to a MaxMatch" do
-          described_class.new.should_not eql(MaxMatch.new)
+          expect(described_class.new).not_to eql(MaxMatch.new)
         end
       end
     end

data/spec/ruby_speech/grxml/matcher_spec.rb

@@ -23,17 +23,17 @@ module RubySpeech
                                               :confidence     => 1,
                                               :utterance      => '6',
                                               :interpretation => 'dtmf-6'
-            subject.match(input).should == expected_match
-            input.should == '6'
+            expect(subject.match(input)).to eq(expected_match)
+            expect(input).to eq('6')
           end
 
           it "should potentially match an empty buffer" do
-            subject.match('').should == GRXML::PotentialMatch.new
+            expect(subject.match('')).to eq(GRXML::PotentialMatch.new)
           end
 
           %w{1 2 3 4 5 7 8 9 10 66 26 61}.each do |input|
             it "should not match '#{input}'" do
-              subject.match(input).should == GRXML::NoMatch.new
+              expect(subject.match(input)).to eq(GRXML::NoMatch.new)
             end
           end
         end
@@ -69,7 +69,7 @@ module RubySpeech
           it "should return the literal tag interpretation" do
             expected_match = GRXML::MaxMatch.new mode: :dtmf, confidence: 1,
               utterance: '2', interpretation: 'bar'
-            subject.match('2').should == expected_match
+            expect(subject.match('2')).to eq(expected_match)
           end
         end
 
@@ -87,18 +87,18 @@ module RubySpeech
                                               :confidence     => 1,
                                               :utterance      => '56',
                                               :interpretation => 'dtmf-5 dtmf-6'
-            subject.match('56').should == expected_match
+            expect(subject.match('56')).to eq(expected_match)
           end
 
           it "should potentially match '5'" do
             input = '5'
-            subject.match(input).should == GRXML::PotentialMatch.new
-            input.should == '5'
+            expect(subject.match(input)).to eq(GRXML::PotentialMatch.new)
+            expect(input).to eq('5')
           end
 
           %w{* *7 #6 6* 1 2 3 4 6 7 8 9 10 65 57 46 26 61}.each do |input|
             it "should not match '#{input}'" do
-              subject.match(input).should == GRXML::NoMatch.new
+              expect(subject.match(input)).to eq(GRXML::NoMatch.new)
             end
           end
         end
@@ -117,16 +117,16 @@ module RubySpeech
                                               :confidence     => 1,
                                               :utterance      => '*6',
                                               :interpretation => 'dtmf-star dtmf-6'
-            subject.match('*6').should == expected_match
+            expect(subject.match('*6')).to eq(expected_match)
           end
 
           it "should potentially match '*'" do
-            subject.match('*').should == GRXML::PotentialMatch.new
+            expect(subject.match('*')).to eq(GRXML::PotentialMatch.new)
           end
 
           %w{*7 #6 6* 1 2 3 4 5 6 7 8 9 10 66 26 61}.each do |input|
             it "should not match '#{input}'" do
-              subject.match(input).should == GRXML::NoMatch.new
+              expect(subject.match(input)).to eq(GRXML::NoMatch.new)
             end
           end
         end
@@ -145,16 +145,16 @@ module RubySpeech
                                               :confidence     => 1,
                                               :utterance      => '#6',
                                               :interpretation => 'dtmf-pound dtmf-6'
-            subject.match('#6').should == expected_match
+            expect(subject.match('#6')).to eq(expected_match)
           end
 
           it "should potentially match '#'" do
-            subject.match('#').should == GRXML::PotentialMatch.new
+            expect(subject.match('#')).to eq(GRXML::PotentialMatch.new)
           end
 
           %w{* *6 #7 6* 1 2 3 4 5 6 7 8 9 10 66 26 61}.each do |input|
             it "should not match '#{input}'" do
-              subject.match(input).should == GRXML::NoMatch.new
+              expect(subject.match(input)).to eq(GRXML::NoMatch.new)
             end
           end
         end
@@ -178,16 +178,16 @@ module RubySpeech
                                               :confidence     => 1,
                                               :utterance      => '*6',
                                               :interpretation => 'dtmf-star dtmf-6'
-            subject.match('*6').should == expected_match
+            expect(subject.match('*6')).to eq(expected_match)
           end
 
           it "should potentially match '*'" do
-            subject.match('*').should == GRXML::PotentialMatch.new
+            expect(subject.match('*')).to eq(GRXML::PotentialMatch.new)
           end
 
           %w{*7 #6 6* 1 2 3 4 5 6 7 8 9 10 66 26 61}.each do |input|
             it "should not match '#{input}'" do
-              subject.match(input).should == GRXML::NoMatch.new
+              expect(subject.match(input)).to eq(GRXML::NoMatch.new)
             end
           end
         end
@@ -209,7 +209,7 @@ module RubySpeech
                                               :confidence     => 1,
                                               :utterance      => '6',
                                               :interpretation => 'dtmf-6'
-            subject.match('6').should == expected_match
+            expect(subject.match('6')).to eq(expected_match)
           end
 
           it "should maximally match '7'" do
@@ -217,12 +217,12 @@ module RubySpeech
                                               :confidence     => 1,
                                               :utterance      => '7',
                                               :interpretation => 'dtmf-7'
-            subject.match('7').should == expected_match
+            expect(subject.match('7')).to eq(expected_match)
           end
 
           %w{* # 1 2 3 4 5 8 9 10 66 26 61}.each do |input|
             it "should not match '#{input}'" do
-              subject.match(input).should == GRXML::NoMatch.new
+              expect(subject.match(input)).to eq(GRXML::NoMatch.new)
             end
           end
         end
@@ -250,7 +250,7 @@ module RubySpeech
                                               :confidence     => 1,
                                               :utterance      => '65',
                                               :interpretation => 'dtmf-6 dtmf-5'
-            subject.match('65').should == expected_match
+            expect(subject.match('65')).to eq(expected_match)
           end
 
           it "should maximally match '72'" do
@@ -258,18 +258,18 @@ module RubySpeech
                                               :confidence     => 1,
                                               :utterance      => '72',
                                               :interpretation => 'dtmf-7 dtmf-2'
-            subject.match('72').should == expected_match
+            expect(subject.match('72')).to eq(expected_match)
           end
 
           %w{6 7}.each do |input|
             it "should potentially match '#{input}'" do
-              subject.match(input).should == GRXML::PotentialMatch.new
+              expect(subject.match(input)).to eq(GRXML::PotentialMatch.new)
             end
           end
 
           %w{* # 1 2 3 4 5 8 9 10 66 26 61 75}.each do |input|
             it "should not match '#{input}'" do
-              subject.match(input).should == GRXML::NoMatch.new
+              expect(subject.match(input)).to eq(GRXML::NoMatch.new)
             end
           end
         end
@@ -299,7 +299,7 @@ module RubySpeech
                                               :confidence     => 1,
                                               :utterance      => '652',
                                               :interpretation => 'dtmf-6 dtmf-5 dtmf-2'
-            subject.match('652').should == expected_match
+            expect(subject.match('652')).to eq(expected_match)
           end
 
           it "should maximally match '728'" do
@@ -307,18 +307,18 @@ module RubySpeech
                                               :confidence     => 1,
                                               :utterance      => '728',
                                               :interpretation => 'dtmf-7 dtmf-2 dtmf-8'
-            subject.match('728').should == expected_match
+            expect(subject.match('728')).to eq(expected_match)
           end
 
           %w{6 65 7 72}.each do |input|
             it "should potentially match '#{input}'" do
-              subject.match(input).should == GRXML::PotentialMatch.new
+              expect(subject.match(input)).to eq(GRXML::PotentialMatch.new)
             end
           end
 
           %w{* # 1 2 3 4 5 8 9 10 66 26 61 75 729 654}.each do |input|
             it "should not match '#{input}'" do
-              subject.match(input).should == GRXML::NoMatch.new
+              expect(subject.match(input)).to eq(GRXML::NoMatch.new)
             end
           end
         end
@@ -341,7 +341,7 @@ module RubySpeech
                                               :confidence     => 1,
                                               :utterance      => '*6',
                                               :interpretation => 'dtmf-star dtmf-6'
-            subject.match('*6').should == expected_match
+            expect(subject.match('*6')).to eq(expected_match)
           end
 
           it "should maximally match '*7'" do
@@ -349,16 +349,16 @@ module RubySpeech
                                               :confidence     => 1,
                                               :utterance      => '*7',
                                               :interpretation => 'dtmf-star dtmf-7'
-            subject.match('*7').should == expected_match
+            expect(subject.match('*7')).to eq(expected_match)
           end
 
           it "should potentially match '*'" do
-            subject.match('*').should == GRXML::PotentialMatch.new
+            expect(subject.match('*')).to eq(GRXML::PotentialMatch.new)
           end
 
           %w{*8 #6 6* 1 2 3 4 5 6 7 8 9 10 66 26 61}.each do |input|
             it "should not match '#{input}'" do
-              subject.match(input).should == GRXML::NoMatch.new
+              expect(subject.match(input)).to eq(GRXML::NoMatch.new)
             end
           end
         end
@@ -381,7 +381,7 @@ module RubySpeech
                                               :confidence     => 1,
                                               :utterance      => '6*',
                                               :interpretation => 'dtmf-6 dtmf-star'
-            subject.match('6*').should == expected_match
+            expect(subject.match('6*')).to eq(expected_match)
           end
 
           it "should maximally match '7*'" do
@@ -389,22 +389,22 @@ module RubySpeech
                                               :confidence     => 1,
                                               :utterance      => '7*',
                                               :interpretation => 'dtmf-7 dtmf-star'
-            subject.match('7*').should == expected_match
+            expect(subject.match('7*')).to eq(expected_match)
           end
 
           %w{6 7}.each do |input|
             it "should potentially match '#{input}'" do
-              subject.match(input).should == GRXML::PotentialMatch.new
+              expect(subject.match(input)).to eq(GRXML::PotentialMatch.new)
             end
           end
 
           it "should potentially match '7'" do
-            subject.match('7').should == GRXML::PotentialMatch.new
+            expect(subject.match('7')).to eq(GRXML::PotentialMatch.new)
           end
 
           %w{8* 6# *6 *7 1 2 3 4 5 8 9 10 66 26 61}.each do |input|
             it "should not match '#{input}'" do
-              subject.match(input).should == GRXML::NoMatch.new
+              expect(subject.match(input)).to eq(GRXML::NoMatch.new)
             end
           end
         end
@@ -426,18 +426,18 @@ module RubySpeech
                                               :confidence     => 1,
                                               :utterance      => '166',
                                               :interpretation => 'dtmf-1 dtmf-6 dtmf-6'
-            subject.match('166').should == expected_match
+            expect(subject.match('166')).to eq(expected_match)
           end
 
           %w{1 16}.each do |input|
             it "should potentially match '#{input}'" do
-              subject.match(input).should == GRXML::PotentialMatch.new
+              expect(subject.match(input)).to eq(GRXML::PotentialMatch.new)
             end
           end
 
           %w{1666 16666 17}.each do |input|
             it "should not match '#{input}'" do
-              subject.match(input).should == GRXML::NoMatch.new
+              expect(subject.match(input)).to eq(GRXML::NoMatch.new)
             end
           end
         end
@@ -459,18 +459,18 @@ module RubySpeech
                                               :confidence     => 1,
                                               :utterance      => '661',
                                               :interpretation => 'dtmf-6 dtmf-6 dtmf-1'
-            subject.match('661').should == expected_match
+            expect(subject.match('661')).to eq(expected_match)
           end
 
           %w{6 66}.each do |input|
             it "should potentially match '#{input}'" do
-              subject.match(input).should == GRXML::PotentialMatch.new
+              expect(subject.match(input)).to eq(GRXML::PotentialMatch.new)
             end
           end
 
           %w{61 6661 66661 71 771}.each do |input|
             it "should not match '#{input}'" do
-              subject.match(input).should == GRXML::NoMatch.new
+              expect(subject.match(input)).to eq(GRXML::NoMatch.new)
             end
           end
         end
@@ -492,7 +492,7 @@ module RubySpeech
                                               :confidence     => 1,
                                               :utterance      => '1666',
                                               :interpretation => 'dtmf-1 dtmf-6 dtmf-6 dtmf-6'
-            subject.match('1666').should == expected_match
+            expect(subject.match('1666')).to eq(expected_match)
           end
 
           {
@@ -505,13 +505,57 @@ module RubySpeech
                                                 :confidence     => 1,
                                                 :utterance      => input,
                                                 :interpretation => interpretation
-              subject.match(input).should == expected_match
+              expect(subject.match(input)).to eq(expected_match)
             end
           end
 
           %w{6 16666 17}.each do |input|
             it "should not match '#{input}'" do
-              subject.match(input).should == GRXML::NoMatch.new
+              expect(subject.match(input)).to eq(GRXML::NoMatch.new)
+            end
+          end
+        end
+
+        context "with a grammar that takes a a specific digit repeated within a range" do
+          let(:grammar) do
+            GRXML.draw :mode => :dtmf, :root => 'digits' do
+              rule :id => 'digits' do
+                item :repeat => 0..3 do
+                  '6'
+                end
+              end
+            end
+          end
+
+          {
+            '' => '',
+            '6' => 'dtmf-6',
+            '66' => 'dtmf-6 dtmf-6',
+          }.each_pair do |input, interpretation|
+            it "should match '#{input}'" do
+              expected_match = GRXML::Match.new :mode           => :dtmf,
+                                                :confidence     => 1,
+                                                :utterance      => input,
+                                                :interpretation => interpretation
+              expect(subject.match(input)).to eq(expected_match)
+            end
+          end
+
+          {
+            '666' => 'dtmf-6 dtmf-6 dtmf-6',
+          }.each_pair do |input, interpretation|
+            it "should maximally match '#{input}'" do
+              expected_match = GRXML::MaxMatch.new :mode        => :dtmf,
+                                                :confidence     => 1,
+                                                :utterance      => input,
+                                                :interpretation => interpretation
+              expect(subject.match(input)).to eq(expected_match)
+            end
+          end
+
+          %w{6666 7}.each do |input|
+            it "should not match '#{input}'" do
+              expect(subject.match(input)).to eq(GRXML::NoMatch.new)
             end
           end
         end
@@ -539,19 +583,19 @@ module RubySpeech
                                                 :confidence     => 1,
                                                 :utterance      => input,
                                                 :interpretation => interpretation
-              subject.match(input).should == expected_match
+              expect(subject.match(input)).to eq(expected_match)
             end
           end
 
           %w{6 66 666}.each do |input|
             it "should potentially match '#{input}'" do
-              subject.match(input).should == GRXML::PotentialMatch.new
+              expect(subject.match(input)).to eq(GRXML::PotentialMatch.new)
             end
           end
 
           %w{66661 71}.each do |input|
             it "should not match '#{input}'" do
-              subject.match(input).should == GRXML::NoMatch.new
+              expect(subject.match(input)).to eq(GRXML::NoMatch.new)
             end
           end
         end
@@ -578,19 +622,19 @@ module RubySpeech
                                                 :confidence     => 1,
                                                 :utterance      => input,
                                                 :interpretation => interpretation
-              subject.match(input).should == expected_match
+              expect(subject.match(input)).to eq(expected_match)
             end
           end
 
           %w{1 16}.each do |input|
             it "should potentially match '#{input}'" do
-              subject.match(input).should == GRXML::PotentialMatch.new
+              expect(subject.match(input)).to eq(GRXML::PotentialMatch.new)
             end
           end
 
           %w{7 17}.each do |input|
             it "should not match '#{input}'" do
-              subject.match(input).should == GRXML::NoMatch.new
+              expect(subject.match(input)).to eq(GRXML::NoMatch.new)
             end
           end
         end
@@ -617,19 +661,19 @@ module RubySpeech
                                                 :confidence     => 1,
                                                 :utterance      => input,
                                                 :interpretation => interpretation
-              subject.match(input).should == expected_match
+              expect(subject.match(input)).to eq(expected_match)
             end
           end
 
           %w{6 66}.each do |input|
             it "should potentially match '#{input}'" do
-              subject.match(input).should == GRXML::PotentialMatch.new
+              expect(subject.match(input)).to eq(GRXML::PotentialMatch.new)
             end
           end
 
           %w{7 71 61}.each do |input|
             it "should not match '#{input}'" do
-              subject.match(input).should == GRXML::NoMatch.new
+              expect(subject.match(input)).to eq(GRXML::NoMatch.new)
             end
           end
         end
@@ -670,19 +714,19 @@ module RubySpeech
                                                 :confidence     => 1,
                                                 :utterance      => input,
                                                 :interpretation => interpretation
-              subject.match(input).should == expected_match
+              expect(subject.match(input)).to eq(expected_match)
             end
           end
 
           %w{* 1 12 123 1234}.each do |input|
             it "should potentially match '#{input}'" do
-              subject.match(input).should == GRXML::PotentialMatch.new
+              expect(subject.match(input)).to eq(GRXML::PotentialMatch.new)
             end
           end
 
           %w{11111 #1111 *7}.each do |input|
             it "should not match '#{input}'" do
-              subject.match(input).should == GRXML::NoMatch.new
+              expect(subject.match(input)).to eq(GRXML::NoMatch.new)
             end
           end
         end

data/spec/ruby_speech/grxml/max_match_spec.rb

@@ -5,11 +5,11 @@ module RubySpeech
     describe MaxMatch do
       it_behaves_like "match"
 
-      it { should be_a Match }
+      it { is_expected.to be_a Match }
 
       describe "equality" do
         it "should never be equal to a MaxMatch" do
-          described_class.new.should_not eql(Match.new)
+          expect(described_class.new).not_to eql(Match.new)
         end
       end
     end

data/spec/ruby_speech/grxml/no_match_spec.rb

@@ -5,11 +5,11 @@ module RubySpeech
     describe NoMatch do
       describe "equality" do
         it "should be equal to another NoMatch" do
-          NoMatch.new.should == NoMatch.new
+          expect(NoMatch.new).to eq(NoMatch.new)
         end
 
         it "should not equal a match" do
-          NoMatch.new.should_not == Match.new
+          expect(NoMatch.new).not_to eq(Match.new)
         end
       end
     end