lame 0.0.3 → 0.0.4

data/spec/decoder_spec.rb

@@ -3,16 +3,16 @@ require 'spec_helper'
 module LAME
   describe Decoder do
 
-    let(:decode_flags)           { stub("decode flags") }
-    let(:mp3_file)               { stub("mp3 file") }
-    let(:id3_tag_parser)         { stub("id3 tag parser", :skip! => nil) }
-    let(:mp3_data_header_parser) { stub("mp3 data header parser", :parse! => nil) }
+    let(:decode_flags)           { double("decode flags") }
+    let(:mp3_file)               { double("mp3 file") }
+    let(:id3_tag_parser)         { double("id3 tag parser", :skip! => nil) }
+    let(:mp3_data_header_parser) { double("mp3 data header parser", :parse! => nil) }
 
     # Stub away all collaborators:
     before do
-      Decoding::Id3TagParser.stub(:new).and_return(id3_tag_parser)
-      Decoding::Mp3DataHeaderParser.stub(:new).and_return(mp3_data_header_parser)
-      FFI::DecodeFlags.stub(:new).and_return(decode_flags)
+      allow(Decoding::Id3TagParser).to receive(:new).and_return(id3_tag_parser)
+      allow(Decoding::Mp3DataHeaderParser).to receive(:new).and_return(mp3_data_header_parser)
+      allow(FFI::DecodeFlags).to receive(:new).and_return(decode_flags)
     end
 
     subject(:decoder) { Decoder.new(mp3_file) }
@@ -20,74 +20,74 @@ module LAME
     context "initialization" do
 
       it "initializes DecodeFlags" do
-        FFI::DecodeFlags.should_receive(:new)
+        expect(FFI::DecodeFlags).to receive(:new)
         Decoder.new(mp3_file)
       end
 
       it "has the DecodeFlags" do
-        decode_flags = stub
-        FFI::DecodeFlags.stub(:new).and_return(decode_flags)
-        decoder.decode_flags.should eql decode_flags
+        decode_flags = double("decode_flags")
+        allow(FFI::DecodeFlags).to receive(:new).and_return(decode_flags)
+        expect(decoder.decode_flags).to eql decode_flags
       end
 
       it "has the mp3 file path" do
-        decoder.mp3_file.should eql mp3_file
+        expect(decoder.mp3_file).to eql mp3_file
       end
 
       it "skips the id3 offset" do
-        Decoding::Id3TagParser.should_receive(:new).with(mp3_file)
-        id3_tag_parser.should_receive(:skip!)
+        expect(Decoding::Id3TagParser).to receive(:new).with(mp3_file)
+        expect(id3_tag_parser).to receive(:skip!)
 
         decoder
       end
 
       it "parses the mp3 data header" do
-        parser = stub
-        mp3_data = stub
-        Decoding::Mp3DataHeaderParser.should_receive(:new).with(decode_flags, mp3_file).and_return(parser)
-        parser.should_receive(:parse!).and_return(mp3_data)
+        parser = double("parser")
+        mp3_data = double("mp3_data")
+        expect(Decoding::Mp3DataHeaderParser).to receive(:new).with(decode_flags, mp3_file).and_return(parser)
+        expect(parser).to receive(:parse!).and_return(mp3_data)
 
-        decoder.mp3_data.should eql mp3_data
+        expect(decoder.mp3_data).to eql mp3_data
       end
 
     end
 
     context "after initialization" do
 
-      let(:mp3_data) { stub("mp3 data") }
+      let(:mp3_data) { double("mp3 data") }
 
       # stubbing galore!
       before do
-        FFI::DecodeFlags.stub(:new).and_return(decode_flags)
+        allow(FFI::DecodeFlags).to receive(:new).and_return(decode_flags)
 
-        parser = stub
-        Decoding::Mp3DataHeaderParser.stub(:new).and_return(parser)
-        parser.stub(:parse!).and_return(mp3_data)
+        parser = double("parser")
+        allow(Decoding::Mp3DataHeaderParser).to receive(:new).and_return(parser)
+        allow(parser).to receive(:parse!).and_return(mp3_data)
       end
 
       describe "#each_decoded_frame" do
 
-        let(:stream_decoder) { stub }
+        let(:stream_decoder) { double("stream_decoder") }
         before do
-          Decoding::StreamDecoder.stub(:new).and_return(stream_decoder)
+          allow(Decoding::StreamDecoder).to receive(:new).and_return(stream_decoder)
         end
 
         it "initializes a stream decoder with mp3 file and mp3 data" do
-          stream_decoder.stub(:each_decoded_frame)
+          allow(stream_decoder).to receive(:each_decoded_frame)
 
-          Decoding::StreamDecoder.should_receive(:new).with(decode_flags, mp3_data, mp3_file)
+          expect(Decoding::StreamDecoder).to receive(:new).with(decode_flags, mp3_data, mp3_file)
 
           decoder.each_decoded_frame
         end
 
         it "delegates to a stream decoder" do
-          stream_decoder.should_receive(:each_decoded_frame)
+          expect(stream_decoder).to receive(:each_decoded_frame)
 
           decoder.each_decoded_frame
         end
 
         it "re-yields the stream decoder's yield" do
-          stream_decoder.stub(:each_decoded_frame).and_yield(:one).and_yield(:two)
+          allow(stream_decoder).to receive(:each_decoded_frame).and_yield(:one).and_yield(:two)
 
           expect { |block|
             decoder.each_decoded_frame(&block)
@@ -99,8 +99,8 @@ module LAME
       describe "#channel_mode" do
 
         it "delegates to mp3_data" do
-          mp3_data.should_receive(:channel_mode).and_return(:stereo)
-          decoder.channel_mode.should eql :stereo
+          expect(mp3_data).to receive(:channel_mode).and_return(:stereo)
+          expect(decoder.channel_mode).to eql :stereo
         end
 
       end
@@ -108,8 +108,8 @@ module LAME
       describe "#sample_rate" do
 
         it "delegates to mp3_data" do
-          mp3_data.should_receive(:sample_rate).and_return(44100)
-          decoder.sample_rate.should eql 44100
+          allow(mp3_data).to receive(:sample_rate).and_return(44100)
+          expect(decoder.sample_rate).to eql 44100
         end
 
       end

data/spec/decoding/decoded_frame_spec.rb

@@ -5,13 +5,13 @@ module LAME
     describe DecodedFrame do
 
       it "is initialized with left and right samples" do
-        left = stub
-        right = stub
+        left = double("left")
+        right = double("right")
 
         decoded_frame = DecodedFrame.new(left, right)
 
-        decoded_frame.left.should eql left
-        decoded_frame.right.should eql right
+        expect(decoded_frame.left).to eql left
+        expect(decoded_frame.right).to eql right
       end
 
       it "can be built with FFI Buffers" do
@@ -23,8 +23,8 @@ module LAME
 
         decoded_frame = DecodedFrame.from_short_buffers(left_buffer, right_buffer)
 
-        decoded_frame.left.should eql [1,2,3,4]
-        decoded_frame.right.should eql [5,6,7,8]
+        expect(decoded_frame.left).to eql [1,2,3,4]
+        expect(decoded_frame.right).to eql [5,6,7,8]
       end
 
       describe "#samples" do
@@ -35,7 +35,7 @@ module LAME
 
           decoded_frame = DecodedFrame.new(left, right)
 
-          decoded_frame.samples.should eql [[1,5],[2,6],[3,7],[4,8]]
+          expect(decoded_frame.samples).to eql [[1,5],[2,6],[3,7],[4,8]]
         end
       end
 

data/spec/decoding/id3_tag_parser_spec.rb

@@ -21,13 +21,13 @@ module LAME
 
           it "seeks the file until after the id3 tag" do
             parser.skip!
-            stream.pos.should eql 351
+            expect(stream.pos).to eql 351
           end
 
           it "start from the start of the stream" do
             stream.seek(42)
             parser.skip!
-            stream.pos.should eql 351
+            expect(stream.pos).to eql 351
           end
         end
 
@@ -43,7 +43,7 @@ module LAME
 
           it "does not seek the stream if no header is present" do
             parser.skip!
-            stream.pos.should eql 0
+            expect(stream.pos).to eql 0
           end
         end
 

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