lame 0.0.3 → 0.0.5

data/spec/decoding/mp3_data_header_parser_spec.rb

@@ -6,22 +6,22 @@ module LAME
 
       subject(:parser) { Mp3DataHeaderParser.new(decode_flags, stream) }
 
-      let(:decode_flags) { stub("decode flags") }
+      let(:decode_flags) { double("decode flags") }
       let(:stream) { StringIO.new(stream_string) }
-      let(:mpeg_finder) { stub }
+      let(:mpeg_finder) { double("mpeg_finder") }
 
       let(:stream_string) { "a"*100 }
 
       before do
-        LAME.stub(:hip_decode1_headersB) do |_, _, _, _, _, mp3_data, _, _|
+        allow(LAME).to receive(:hip_decode1_headersB) do |_, _, _, _, _, mp3_data, _, _|
           # fake that the header was found
           mp3_data[:header_parsed] = 1
         end
       end
 
       it "seeks the input stream until the first mpeg frame" do
-        MPEGAudioFrameFinder.should_receive(:new).with(stream).and_return(mpeg_finder)
-        mpeg_finder.should_receive(:find!)
+        expect(MPEGAudioFrameFinder).to receive(:new).with(stream).and_return(mpeg_finder)
+        expect(mpeg_finder).to receive(:find!)
 
         parser.parse!
       end
@@ -29,20 +29,20 @@ module LAME
       context "decoding headers" do
 
         before do
-          MPEGAudioFrameFinder.stub(:new => stub.as_null_object)
+          allow(MPEGAudioFrameFinder).to receive(:new).and_return(double.as_null_object)
         end
 
         it "reads 100 bytes from the stream" do
-          stream.should_receive(:read).with(100).and_return("a"*100)
+          expect(stream).to receive(:read).with(100).and_return("a"*100)
           parser.parse!
         end
 
         it "parses headers with LAME" do
-          LAME.should_receive(:hip_decode1_headersB) do |decode_flags, in_buffer, size, _, _, mp3_data, _, _|
-            decode_flags.should            eql decode_flags
-            in_buffer.get_string(0).should eql "a"*100
-            size.should                    eql 100
-            mp3_data.should                be_a(LAME::FFI::MP3Data)
+          expect(LAME).to receive(:hip_decode1_headersB) do |decode_flags, in_buffer, size, _, _, mp3_data, _, _|
+            expect(decode_flags).to            eql decode_flags
+            expect(in_buffer.get_string(0)).to eql "a"*100
+            expect(size).to                    eql 100
+            expect(mp3_data).to                be_a(LAME::FFI::MP3Data)
 
             # fake that the header was found
             mp3_data[:header_parsed] = 1
@@ -57,9 +57,9 @@ module LAME
           it "reads 100 bytes until a header was parsed" do
             decode_count = 0
 
-            LAME.should_receive(:hip_decode1_headersB).exactly(expected_reads).times
+            expect(LAME).to receive(:hip_decode1_headersB).exactly(expected_reads).times
 
-            LAME.stub(:hip_decode1_headersB) do |_, _, _, _, _, mp3_data, _, _|
+            allow(LAME).to receive(:hip_decode1_headersB) do |_, _, _, _, _, mp3_data, _, _|
               decode_count += 1
 
               # simulate parsed header after 5 reads:
@@ -71,17 +71,17 @@ module LAME
         end
 
         it "returns the parsed mp3 data if a header was parsed" do
-          mp3_data = stub("mp3 data", :header_parsed? => true)
-          LAME::FFI::MP3Data.stub(:new).and_return(mp3_data)
-          LAME.stub(:hip_decode1_headersB)
+          mp3_data = double("mp3 data", :header_parsed? => true)
+          allow(LAME::FFI::MP3Data).to receive(:new).and_return(mp3_data)
+          allow(LAME).to receive(:hip_decode1_headersB)
 
-          parser.parse!.should eql mp3_data
+          expect(parser.parse!).to eql mp3_data
         end
 
         it "raises an error if the header could not be parsed" do
-          mp3_data = stub("mp3 data", :header_parsed? => false)
-          LAME::FFI::MP3Data.stub(:new).and_return(mp3_data)
-          LAME.stub(:hip_decode1_headersB)
+          mp3_data = double("mp3 data", :header_parsed? => false)
+          allow(LAME::FFI::MP3Data).to receive(:new).and_return(mp3_data)
+          allow(LAME).to receive(:hip_decode1_headersB)
 
           expect {
             parser.parse!

data/spec/decoding/mpeg_audio_frame_finder_spec.rb

@@ -10,35 +10,35 @@ module LAME
       let(:stream_string) { "1234567890" }
 
       it "tries to find the mpeg frame 4 bytes at a time until a header is found" do
-        matcher1 = stub("matcher", :match? => false)
-        matcher2 = stub("matcher", :match? => false)
-        matcher3 = stub("matcher", :match? => true)
+        matcher1 = double("matcher", :match? => false)
+        matcher2 = double("matcher", :match? => false)
+        matcher3 = double("matcher", :match? => true)
 
-        MPEGAudioFrameMatcher.should_receive(:new).with("1234").and_return(matcher1)
-        MPEGAudioFrameMatcher.should_receive(:new).with("2345").and_return(matcher2)
-        MPEGAudioFrameMatcher.should_receive(:new).with("3456").and_return(matcher3)
+        expect(MPEGAudioFrameMatcher).to receive(:new).with("1234").and_return(matcher1)
+        expect(MPEGAudioFrameMatcher).to receive(:new).with("2345").and_return(matcher2)
+        expect(MPEGAudioFrameMatcher).to receive(:new).with("3456").and_return(matcher3)
 
         finder.find!
       end
 
       it "seeks the stream at the position of the found frame" do
-        matcher1 = stub("matcher", :match? => false)
-        matcher2 = stub("matcher", :match? => false)
-        matcher3 = stub("matcher", :match? => true)
+        matcher1 = double("matcher", :match? => false)
+        matcher2 = double("matcher", :match? => false)
+        matcher3 = double("matcher", :match? => true)
 
-        MPEGAudioFrameMatcher.stub(:new).with("1234").and_return(matcher1)
-        MPEGAudioFrameMatcher.stub(:new).with("2345").and_return(matcher2)
-        MPEGAudioFrameMatcher.stub(:new).with("3456").and_return(matcher3)
+        allow(MPEGAudioFrameMatcher).to receive(:new).with("1234").and_return(matcher1)
+        allow(MPEGAudioFrameMatcher).to receive(:new).with("2345").and_return(matcher2)
+        allow(MPEGAudioFrameMatcher).to receive(:new).with("3456").and_return(matcher3)
 
         finder.find!
 
-        stream.pos.should eql 2
+        expect(stream.pos).to eql 2
       end
 
       it "raises an error if no header could be found" do
-        matcher = stub("matcher", :match? => false)
+        matcher = double("matcher", :match? => false)
 
-        MPEGAudioFrameMatcher.stub(:new).and_return(matcher)
+        allow(MPEGAudioFrameMatcher).to receive(:new).and_return(matcher)
 
         expect {
           finder.find!

data/spec/decoding/mpeg_audio_frame_matcher_spec.rb

@@ -41,14 +41,14 @@ module LAME
       shared_examples_for "4 valid bytes" do
         it "matches" do
           bytes = [b1, b2, b3, b4].pack("C*")
-          MPEGAudioFrameMatcher.new(bytes).match?.should be_true
+          expect(MPEGAudioFrameMatcher.new(bytes).match?).to be_truthy
         end
       end
 
       shared_examples_for "4 invalid bytes" do
         it "does not match" do
           bytes = [b1, b2, b3, b4].pack("C*")
-          MPEGAudioFrameMatcher.new(bytes).match?.should be_false
+          expect(MPEGAudioFrameMatcher.new(bytes).match?).to be_falsy
         end
       end
 

data/spec/decoding/single_frame_decoder_spec.rb

@@ -6,41 +6,41 @@ module LAME
 
       subject(:decoder) { SingleFrameDecoder.new(decode_flags, mp3_data) }
 
-      let(:decode_flags) { stub("decode flags") }
-      let(:mp3_data) { stub("mp3 data") }
+      let(:decode_flags) { double("decode flags") }
+      let(:mp3_data) { double("mp3 data") }
       let(:data) { "a"*1024 }
 
       it "always checks if there is a decoded frame in the internal buffer" do
         # initial decoded frame
-        LAME.should_receive(:hip_decode1_headers) do |flags, in_buffer, in_size, out_left, out_right, mp3_data_arg|
-          flags.should          eql decode_flags
-          in_buffer.size.should eql 0
-          in_size.should        eql 0
-          out_left.size.should  eql 1152*2 # short is 2 bytes
-          out_right.size.should eql 1152*2
-          mp3_data_arg.should   eql mp3_data
+        expect(LAME).to receive(:hip_decode1_headers) do |flags, in_buffer, in_size, out_left, out_right, mp3_data_arg|
+          expect(flags).to          eql decode_flags
+          expect(in_buffer.size).to eql 0
+          expect(in_size).to        eql 0
+          expect(out_left.size).to  eql 1152*2 # short is 2 bytes
+          expect(out_right.size).to eql 1152*2
+          expect(mp3_data_arg).to   eql mp3_data
           0
         end
         # new data
-        LAME.stub(:hip_decode1_headers).and_return(0)
+        allow(LAME).to receive(:hip_decode1_headers).and_return(0)
 
         decoder.decode(data)
       end
 
       it "writes the input data into the LAME decoder" do
         # initial
-        LAME.should_receive(:hip_decode1_headers) do |_, in_buffer, _, _ , _, _|
-          in_buffer.size.should eql 0
+        expect(LAME).to receive(:hip_decode1_headers) do |_, in_buffer, _, _ , _, _|
+          expect(in_buffer.size).to eql 0
           0
         end
         # new data
-        LAME.should_receive(:hip_decode1_headers) do |flags, in_buffer, in_size, out_left, out_right, mp3_data_arg|
-          flags.should          eql decode_flags
-          in_buffer.size.should eql 1024
-          in_size.should        eql 1024
-          out_left.size.should  eql 1152*2 # short is 2 bytes
-          out_right.size.should eql 1152*2
-          mp3_data_arg.should   eql mp3_data
+        expect(LAME).to receive(:hip_decode1_headers) do |flags, in_buffer, in_size, out_left, out_right, mp3_data_arg|
+          expect(flags).to          eql decode_flags
+          expect(in_buffer.size).to eql 1024
+          expect(in_size).to        eql 1024
+          expect(out_left.size).to  eql 1152*2 # short is 2 bytes
+          expect(out_right.size).to eql 1152*2
+          expect(mp3_data_arg).to   eql mp3_data
           0
         end
 
@@ -48,14 +48,14 @@ module LAME
       end
 
       it "decodes until no more frames were decoded" do
-        LAME.stub(:hip_decode1_headers).and_return(0, 1, 1, 0)
-        LAME.should_receive(:hip_decode1_headers).exactly(4).times
+        allow(LAME).to receive(:hip_decode1_headers).and_return(0, 1, 1, 0)
+        expect(LAME).to receive(:hip_decode1_headers).exactly(4).times
 
         decoder.decode(data) {}
       end
 
       it "yields decoded frames if one is left in internal buffer" do
-        LAME.stub(:hip_decode1_headers).and_return(1, 0)
+        allow(LAME).to receive(:hip_decode1_headers).and_return(1, 0)
 
         expect { |block|
           decoder.decode(data, &block)
@@ -63,7 +63,7 @@ module LAME
       end
 
       it "yields decoded frames for new data" do
-        LAME.stub(:hip_decode1_headers).and_return(0, 1, 1, 0)
+        allow(LAME).to receive(:hip_decode1_headers).and_return(0, 1, 1, 0)
 
         expect { |block|
           decoder.decode(data, &block)
@@ -71,31 +71,32 @@ module LAME
       end
 
       it "raises an error if decoding failed" do
-        LAME.stub(:hip_decode1_headers).and_return(-1)
+        allow(LAME).to receive(:hip_decode1_headers).and_return(-1)
 
         expect {
           decoder.decode(data)
         }.to raise_error(DecodingError)
       end
 
-      # Enable these tests once next rspec-expectations has been released
-      xit "yields until no more data is decoded" do
-        LAME.stub(:hip_decode1_headers).and_return(0, 1, 1, 0)
+      it "yields until no more data is decoded" do
+        allow(LAME).to receive(:hip_decode1_headers).and_return(0, 1, 1, 0)
 
-        LAME.should_receive(:hip_decode1_headers).exactly(4).times
+        expect(LAME).to receive(:hip_decode1_headers).exactly(4).times
 
-        expect {
-          decoder.decode(data)
+        expect { |block|
+          decoder.decode(data, &block)
         }.to yield_control.exactly(2).times
       end
 
-      xit "yields if the decoder had a decoded frame " do
-        LAME.stub(:hip_decode1_headers).and_return(1, 1, 1, 0)
+      it "yields if the decoder still had a decoded frame " do
+        # the initial '1' indicates a frame was still in the internal buffer (flush)
+        # the subsequent '1's are newly decoded frames
+        allow(LAME).to receive(:hip_decode1_headers).and_return(1, 0, 1, 1, 0)
 
-        LAME.should_receive(:hip_decode1_headers).exactly(4).times
+        expect(LAME).to receive(:hip_decode1_headers).exactly(5).times
 
-        expect {
-          decoder.decode(data)
+        expect { |block|
+          decoder.decode(data, &block)
         }.to yield_control.exactly(3).times
       end
 

data/spec/decoding/stream_decoder_spec.rb

@@ -6,32 +6,32 @@ module LAME
 
       subject(:decoder) { StreamDecoder.new(decode_flags, mp3_data, stream) }
 
-      let(:decode_flags) { stub("decode flags") }
-      let(:mp3_data) { stub("mp3 data") }
+      let(:decode_flags) { double("decode flags") }
+      let(:mp3_data) { double("mp3 data") }
 
       let(:stream) { StringIO.new(stream_string) }
       let(:stream_string) { "a" * 1024 + "b" * 1024}
 
       it "creates a single frame decoder" do
-        SingleFrameDecoder.should_receive(:new).with(decode_flags, mp3_data)
+        expect(SingleFrameDecoder).to receive(:new).with(decode_flags, mp3_data)
         decoder
       end
 
       it "it passes chunks of stream into the single frame decoder" do
-        single_frame_decoder = stub
-        SingleFrameDecoder.stub(:new).and_return(single_frame_decoder)
+        single_frame_decoder = double("single_frame_decoder")
+        allow(SingleFrameDecoder).to receive(:new).and_return(single_frame_decoder)
 
-        single_frame_decoder.should_receive(:decode).exactly(:twice)
+        expect(single_frame_decoder).to receive(:decode).exactly(:twice)
 
         decoder.each_decoded_frame
       end
 
       it "yields the decoded frame" do
-        single_frame_decoder = stub
-        SingleFrameDecoder.stub(:new).and_return(single_frame_decoder)
+        single_frame_decoder = double("single frame decoder")
+        allow(SingleFrameDecoder).to receive(:new).and_return(single_frame_decoder)
 
-        single_frame_decoder.stub(:decode).with("a"*1024).and_yield(:one)
-        single_frame_decoder.stub(:decode).with("b"*1024).and_yield(:two).and_yield(:three)
+        allow(single_frame_decoder).to receive(:decode).with("a"*1024).and_yield(:one)
+        allow(single_frame_decoder).to receive(:decode).with("b"*1024).and_yield(:two).and_yield(:three)
 
         expect { |block|
           decoder.each_decoded_frame(&block)

data/spec/delegation_spec.rb

@@ -14,7 +14,7 @@ module LAME
 
   describe Delegation do
 
-    let(:global_flags) { stub }
+    let(:global_flags) { double("global_flags") }
     subject { FakeEncoder.new }
 
     before do
@@ -23,71 +23,71 @@ module LAME
 
     context "#delegate_alias_to_lame" do
       it "delegates #foo= to LAME" do
-        LAME.should_receive(:lame_set_bar).with(global_flags, anything)
-        subject.foo = stub
+        expect(LAME).to receive(:lame_set_bar).with(global_flags, anything)
+        subject.foo = double("delegate")
       end
 
       it "delegates #foo to LAME" do
-        LAME.should_receive(:lame_get_bar).with(global_flags)
+        expect(LAME).to receive(:lame_get_bar).with(global_flags)
         subject.foo
       end
 
       it "delegates #foo? to LAME" do
-        LAME.should_receive(:lame_get_bar).with(global_flags)
+        expect(LAME).to receive(:lame_get_bar).with(global_flags)
         subject.foo?
       end
     end
 
     context "#delegate_to_lame" do
       it "delegates #baz= to LAME" do
-        LAME.should_receive(:lame_set_baz).with(global_flags, anything)
-        subject.baz = stub
+        expect(LAME).to receive(:lame_set_baz).with(global_flags, anything)
+        subject.baz = double("delegate")
       end
 
       it "delegates #baz to LAME" do
-        LAME.should_receive(:lame_get_baz).with(global_flags)
+        expect(LAME).to receive(:lame_get_baz).with(global_flags)
         subject.baz
       end
 
       it "delegates #baz? to LAME" do
-        LAME.should_receive(:lame_get_baz).with(global_flags)
+        expect(LAME).to receive(:lame_get_baz).with(global_flags)
         subject.baz?
       end
     end
 
     context "#delegate_id3_to_lame" do
       it "delegates #qux= to LAME" do
-        LAME.should_receive(:id3tag_set_qux).with(global_flags, anything)
-        subject.qux = stub
+        expect(LAME).to receive(:id3tag_set_qux).with(global_flags, anything)
+        subject.qux = double("delegate")
       end
     end
 
     context "type conversion" do
       it "converts the input type" do
-        value = stub
-        Delegation::TypeConvertor.should_receive(:convert).with(value)
-        LAME.stub(:lame_set_baz)
+        value = double("value")
+        expect(Delegation::TypeConvertor).to receive(:convert).with(value)
+        allow(LAME).to receive(:lame_set_baz)
         subject.baz = value
       end
 
       it "passes on converted value to setter" do
-        value = stub
-        converted_value = stub
-        Delegation::TypeConvertor.stub(:convert).and_return(converted_value)
-        LAME.should_receive(:lame_set_baz).with(global_flags, converted_value)
+        value = double("value")
+        converted_value = double("converted_value")
+        allow(Delegation::TypeConvertor).to receive(:convert).and_return(converted_value)
+        expect(LAME).to receive(:lame_set_baz).with(global_flags, converted_value)
         subject.baz = value
       end
 
       it "converts question mark style getters to return booleans" do
-        LAME.stub(:lame_get_baz).and_return(0)
-        Delegation::TypeConvertor.should_receive(:convert_return).with(0)
+        allow(LAME).to receive(:lame_get_baz).and_return(0)
+        expect(Delegation::TypeConvertor).to receive(:convert_return).with(0)
         subject.baz?
       end
 
       it "converts question mark style getters to return booleans" do
-        LAME.stub(:lame_get_baz)
-        Delegation::TypeConvertor.stub(:convert_return).and_return(false)
-        subject.baz?.should eql false
+        allow(LAME).to receive(:lame_get_baz)
+        allow(Delegation::TypeConvertor).to receive(:convert_return).and_return(false)
+        expect(subject.baz?).to be_falsy
       end
     end
 
@@ -99,45 +99,45 @@ module LAME
 
     describe "#convert" do
       it "converts true to 1" do
-        converter.convert(true).should eql 1
+        expect(converter.convert(true)).to eql 1
       end
 
       it "converts false to 0" do
-        converter.convert(false).should eql 0
+        expect(converter.convert(false)).to eql 0
       end
 
       it "converts a string to a pointer with correct value" do
         input = "some string"
         value = converter.convert(input)
-        value.should be_a(::FFI::MemoryPointer)
-        value.get_string(0).should eql input
+        expect(value).to be_a(::FFI::MemoryPointer)
+        expect(value.get_string(0)).to eql input
       end
 
       it "does not convert other values" do
-        converter.convert(:foo).should eql :foo
-        converter.convert(1.2).should eql 1.2
+        expect(converter.convert(:foo)).to eql :foo
+        expect(converter.convert(1.2)).to eql 1.2
       end
     end
 
     describe "#convert_return" do
       it "converts 1 to true" do
-        converter.convert_return(1).should eql true
+        expect(converter.convert_return(1)).to eql true
       end
 
       it "converts 0 to false" do
-        converter.convert_return(0).should eql false
+        expect(converter.convert_return(0)).to eql false
       end
 
       it "converts 0.0 to false" do
-        converter.convert_return(0.0).should eql false
+        expect(converter.convert_return(0.0)).to eql false
       end
 
       it "returns truthy to true" do
-        converter.convert_return(:truthy).should eql true
-        converter.convert_return("truthy").should eql true
-        converter.convert_return(Object).should eql true
-        converter.convert_return(Object.new).should eql true
-        converter.convert_return(4.2).should eql true
+        expect(converter.convert_return(:truthy)).to eql true
+        expect(converter.convert_return("truthy")).to eql true
+        expect(converter.convert_return(Object)).to eql true
+        expect(converter.convert_return(Object.new)).to eql true
+        expect(converter.convert_return(4.2)).to eql true
       end
     end