lame 0.0.3 → 0.0.5

data/spec/encoder_spec.rb

@@ -8,7 +8,7 @@ module LAME
     context "initialization" do
 
       it "initializes GlobalFlags" do
-        FFI::GlobalFlags.should_receive(:new)
+        expect(FFI::GlobalFlags).to receive(:new)
         Encoder.new
       end
 
@@ -16,14 +16,14 @@ module LAME
 
     context "configuration" do
 
-      let(:configuration) { stub(Configuration).as_null_object }
+      let(:configuration) { double(Configuration).as_null_object }
 
       before do
-        Configuration.stub(:new).and_return(configuration)
+        allow(Configuration).to receive(:new).and_return(configuration)
       end
 
       it "initializes a Configuration object" do
-        Configuration.should_receive(:new).with(kind_of(GlobalFlags))
+        expect(Configuration).to receive(:new).with(kind_of(GlobalFlags))
         encoder.configure { }
       end
 
@@ -35,18 +35,18 @@ module LAME
 
       it "assigns the Configuration object" do
         encoder.configure { }
-        encoder.configuration.should eql configuration
+        expect(encoder.configuration).to eql configuration
       end
 
       it "applies the configuration" do
-        configuration.stub(:applied?).and_return(false)
-        configuration.should_receive(:apply!)
+        allow(configuration).to receive(:applied?).and_return(false)
+        expect(configuration).to receive(:apply!)
         encoder.configure { }
       end
 
       it "gets the framesize" do
-        configuration.should_receive(:framesize).and_return(1234)
-        encoder.framesize.should eql 1234
+        expect(configuration).to receive(:framesize).and_return(1234)
+        expect(encoder.framesize).to eql 1234
       end
     end
 
@@ -57,54 +57,54 @@ module LAME
       let(:samples) { [0,0] }
 
       let(:global_flags) { subject.global_flags }
-      let(:configuration) { stub(Configuration, :framesize => 100) }
+      let(:configuration) { double(Configuration, :framesize => 100) }
 
       before do
-        Configuration.stub(:new).and_return(configuration)
-        configuration.stub(:applied?).and_return(true)
+        allow(Configuration).to receive(:new).and_return(configuration)
+        allow(configuration).to receive(:applied?).and_return(true)
       end
 
       describe "#encode_short" do
 
         before do
-          Encoding::ShortBufferEncoder.stub(:new).and_return(stub.as_null_object)
+          allow(Encoding::ShortBufferEncoder).to receive(:new).and_return(double.as_null_object)
         end
 
         it "applies the configuration if not done already" do
-          configuration.stub(:applied?).and_return(false)
-          configuration.should_receive(:apply!)
+          allow(configuration).to receive(:applied?).and_return(false)
+          expect(configuration).to receive(:apply!)
           encoder.encode_short(left, right) { }
         end
 
         it "does not apply the configuration if already applied" do
-          configuration.stub(:applied?).and_return(true)
-          configuration.should_not_receive(:apply!)
+          allow(configuration).to receive(:applied?).and_return(true)
+          expect(configuration).to_not receive(:apply!)
           encoder.encode_short(left, right) { }
         end
 
         context "delegation" do
-          let(:short_encoder) { stub.as_null_object }
+          let(:short_encoder) { double.as_null_object }
 
           before do
-            Encoding::ShortBufferEncoder.stub(:new).and_return(short_encoder)
+            allow(Encoding::ShortBufferEncoder).to receive(:new).and_return(short_encoder)
           end
 
           it "create a short encoder with configuration" do
-            Encoding::ShortBufferEncoder.should_receive(:new).with(configuration)
+            expect(Encoding::ShortBufferEncoder).to receive(:new).with(configuration)
 
             encoder.encode_short(left, right) { }
           end
 
           it "delegates encoding to the short encoder" do
-            left.stub(:length => 100) # exactly framesize
-            short_encoder.should_receive(:encode_frame).with(left, right)
+            allow(left).to receive_messages(:length => 100) # exactly framesize
+            expect(short_encoder).to receive(:encode_frame).with(left, right)
 
             encoder.encode_short(left, right) { }
           end
 
           it "yields the encoder results" do
-            mp3_data = stub
-            short_encoder.stub(:encode_frame).and_return(mp3_data)
+            mp3_data = double("mp3_data")
+            allow(short_encoder).to receive(:encode_frame).and_return(mp3_data)
 
             expect { |block|
               encoder.encode_short(left, right, &block)
@@ -114,26 +114,26 @@ module LAME
           it "delegates multiple times for large input" do
             right = left = [0]*150 # larger than framesize
 
-            short_encoder.should_receive(:encode_frame) do |left_frame, right_frame|
-              left_frame.length.should eql 100
-              right_frame.length.should eql 100
+            expect(short_encoder).to receive(:encode_frame) do |left_frame, right_frame|
+              expect(left_frame.length).to eql 100
+              expect(right_frame.length).to eql 100
             end
 
-            short_encoder.should_receive(:encode_frame) do |left_frame, right_frame|
-              left_frame.length.should eql 50
-              right_frame.length.should eql 50
+            expect(short_encoder).to receive(:encode_frame) do |left_frame, right_frame|
+              expect(left_frame.length).to eql 50
+              expect(right_frame.length).to eql 50
             end
 
             encoder.encode_short(left, right) { }
           end
 
           it "yields multiple times for large input" do
-            mp3_data1 = stub("frame1")
-            mp3_data2 = stub("frame2")
+            mp3_data1 = double("frame1")
+            mp3_data2 = double("frame2")
 
             left = [0]*150 # larger than framesize
 
-            short_encoder.stub(:encode_frame).and_return(mp3_data1, mp3_data2)
+            allow(short_encoder).to receive(:encode_frame).and_return(mp3_data1, mp3_data2)
 
             expect { |block|
               encoder.encode_short(left, right, &block)
@@ -144,8 +144,8 @@ module LAME
 
       describe "#encode_float" do
         it "create a float encoder" do
-          Encoding::FloatBufferEncoder.stub(:new).and_return(stub.as_null_object)
-          Encoding::FloatBufferEncoder.should_receive(:new).with(configuration)
+          allow(Encoding::FloatBufferEncoder).to receive(:new).and_return(double.as_null_object)
+          expect(Encoding::FloatBufferEncoder).to receive(:new).with(configuration)
 
           encoder.encode_float(left, right) { }
         end
@@ -153,8 +153,8 @@ module LAME
 
       describe "#encode_long" do
         it "create a long encoder" do
-          Encoding::LongBufferEncoder.stub(:new).and_return(stub.as_null_object)
-          Encoding::LongBufferEncoder.should_receive(:new).with(configuration)
+          allow(Encoding::LongBufferEncoder).to receive(:new).and_return(double.as_null_object)
+          expect(Encoding::LongBufferEncoder).to receive(:new).with(configuration)
 
           encoder.encode_long(left, right) { }
         end
@@ -163,44 +163,44 @@ module LAME
       describe "#encode_interleaved_short" do
 
         before do
-          Encoding::InterleavedShortBufferEncoder.stub(:new).and_return(stub.as_null_object)
+          allow(Encoding::InterleavedShortBufferEncoder).to receive(:new).and_return(double.as_null_object)
         end
 
         it "applies the configuration if not done already" do
-          configuration.stub(:applied?).and_return(false)
-          configuration.should_receive(:apply!)
+          allow(configuration).to receive(:applied?).and_return(false)
+          expect(configuration).to receive(:apply!)
           encoder.encode_interleaved_short(samples) { }
         end
 
         it "does not apply the configuration if already applied" do
-          configuration.stub(:applied?).and_return(true)
-          configuration.should_not_receive(:apply!)
+          allow(configuration).to receive(:applied?).and_return(true)
+          expect(configuration).to_not receive(:apply!)
           encoder.encode_interleaved_short(samples) { }
         end
 
         context "delegation" do
-          let(:interleaved_short_encoder) { stub.as_null_object }
+          let(:interleaved_short_encoder) { double.as_null_object }
 
           before do
-            Encoding::InterleavedShortBufferEncoder.stub(:new).and_return(interleaved_short_encoder)
+            allow(Encoding::InterleavedShortBufferEncoder).to receive(:new).and_return(interleaved_short_encoder)
           end
 
           it "create a short encoder with configuration" do
-            Encoding::InterleavedShortBufferEncoder.should_receive(:new).with(configuration)
+            expect(Encoding::InterleavedShortBufferEncoder).to receive(:new).with(configuration)
 
             encoder.encode_interleaved_short(samples) { }
           end
 
           it "delegates encoding to the short encoder" do
-            samples.stub(:length => 200) # exactly framesize
-            interleaved_short_encoder.should_receive(:encode_frame).with(samples)
+            allow(samples).to receive_messages(:length => 200) # exactly framesize
+            expect(interleaved_short_encoder).to receive(:encode_frame).with(samples)
 
             encoder.encode_interleaved_short(samples) { }
           end
 
           it "yields the encoder results" do
-            mp3_data = stub
-            interleaved_short_encoder.stub(:encode_frame).and_return(mp3_data)
+            mp3_data = double("mp3_data")
+            allow(interleaved_short_encoder).to receive(:encode_frame).and_return(mp3_data)
 
             expect { |block|
               encoder.encode_interleaved_short(samples, &block)
@@ -210,24 +210,24 @@ module LAME
           it "delegates multiple times for large input" do
             samples = [0]*300 # larger than framesize
 
-            interleaved_short_encoder.should_receive(:encode_frame) do |samples|
-              samples.length.should eql 200
+            expect(interleaved_short_encoder).to receive(:encode_frame) do |samples|
+              expect(samples.length).to eql 200
             end
 
-            interleaved_short_encoder.should_receive(:encode_frame) do |samples|
-              samples.length.should eql 100
+            expect(interleaved_short_encoder).to receive(:encode_frame) do |samples|
+              expect(samples.length).to eql 100
             end
 
             encoder.encode_interleaved_short(samples) { }
           end
 
           it "yields multiple times for large input" do
-            mp3_data1 = stub("frame1")
-            mp3_data2 = stub("frame2")
+            mp3_data1 = double("frame1")
+            mp3_data2 = double("frame2")
 
             samples = [0]*300 # larger than framesize
 
-            interleaved_short_encoder.stub(:encode_frame).and_return(mp3_data1, mp3_data2)
+            allow(interleaved_short_encoder).to receive(:encode_frame).and_return(mp3_data1, mp3_data2)
 
             expect { |block|
               encoder.encode_interleaved_short(samples, &block)
@@ -238,8 +238,8 @@ module LAME
 
       describe "#encode_interleaved_float" do
         it "create a float encoder" do
-          Encoding::InterleavedFloatBufferEncoder.stub(:new).and_return(stub.as_null_object)
-          Encoding::InterleavedFloatBufferEncoder.should_receive(:new).with(configuration)
+          allow(Encoding::InterleavedFloatBufferEncoder).to receive(:new).and_return(double.as_null_object)
+          expect(Encoding::InterleavedFloatBufferEncoder).to receive(:new).with(configuration)
 
           encoder.encode_interleaved_float(samples) { }
         end
@@ -250,28 +250,28 @@ module LAME
     context "flushing" do
 
       let(:global_flags) { subject.global_flags }
-      let(:configuration) { stub(Configuration) }
-      let(:flusher) { stub(Encoding::Flusher).as_null_object }
+      let(:configuration) { double(Configuration) }
+      let(:flusher) { double(Encoding::Flusher).as_null_object }
 
       before do
-        Configuration.stub(:new).and_return(configuration)
-        configuration.stub(:applied?).and_return(true)
-        Encoding::Flusher.stub(:new).and_return(flusher)
+        allow(Configuration).to receive(:new).and_return(configuration)
+        allow(configuration).to receive(:applied?).and_return(true)
+        allow(Encoding::Flusher).to receive(:new).and_return(flusher)
       end
 
       it "creates a flusher" do
-        Encoding::Flusher.should_receive(:new).with(configuration)
+        expect(Encoding::Flusher).to receive(:new).with(configuration)
         encoder.flush { }
       end
 
       it "flushes the final frame" do
-        flusher.should_receive(:flush)
+        expect(flusher).to receive(:flush)
         encoder.flush { }
       end
 
       it "yields the flushed mp3 data" do
-        mp3_data = stub
-        flusher.stub(:flush).and_return(mp3_data)
+        mp3_data = double("mp3_data")
+        allow(flusher).to receive(:flush).and_return(mp3_data)
 
         expect { |block|
           encoder.flush(&block)
@@ -279,9 +279,9 @@ module LAME
       end
 
       it "returns the flushed data if no block was given" do
-        mp3_data = stub
-        flusher.stub(:flush).and_return(mp3_data)
-        encoder.flush.should eql mp3_data
+        mp3_data = double("mp3_data")
+        allow(flusher).to receive(:flush).and_return(mp3_data)
+        expect(encoder.flush).to eql mp3_data
       end
 
     end
@@ -289,28 +289,28 @@ module LAME
     context "lametag frame" do
 
       let(:global_flags) { subject.global_flags }
-      let(:configuration) { stub(Configuration) }
-      let(:vbr_info) { stub(Encoding::VBRInfo).as_null_object }
+      let(:configuration) { double(Configuration) }
+      let(:vbr_info) { double(Encoding::VBRInfo).as_null_object }
 
       before do
-        Configuration.stub(:new).and_return(configuration)
-        configuration.stub(:applied?).and_return(true)
-        Encoding::VBRInfo.stub(:new).and_return(vbr_info)
+        allow(Configuration).to receive(:new).and_return(configuration)
+        allow(configuration).to receive(:applied?).and_return(true)
+        allow(Encoding::VBRInfo).to receive(:new).and_return(vbr_info)
       end
 
       it "creates vbr info" do
-        Encoding::VBRInfo.should_receive(:new).with(configuration)
+        expect(Encoding::VBRInfo).to receive(:new).with(configuration)
         encoder.vbr_frame { }
       end
 
       it "creates the vbr frame" do
-        vbr_info.should_receive(:frame)
+        expect(vbr_info).to receive(:frame)
         encoder.vbr_frame { }
       end
 
       it "yields the vbr frame" do
-        mp3_data = stub
-        vbr_info.stub(:frame).and_return(mp3_data)
+        mp3_data = double("mp3_data")
+        allow(vbr_info).to receive(:frame).and_return(mp3_data)
 
         expect { |block|
           encoder.vbr_frame(&block)
@@ -318,38 +318,38 @@ module LAME
       end
 
       it "returns the vbr frame if no block was given" do
-        mp3_data = stub
-        vbr_info.stub(:frame).and_return(mp3_data)
-        encoder.vbr_frame.should eql mp3_data
+        mp3_data = double("mp3_data")
+        allow(vbr_info).to receive(:frame).and_return(mp3_data)
+        expect(encoder.vbr_frame).to eql mp3_data
       end
 
     end
 
     context "id3" do
       let(:global_flags) { subject.global_flags }
-      let(:configuration) { stub(Configuration) }
-      let(:id3) { stub(Encoding::Id3).as_null_object }
+      let(:configuration) { double(Configuration) }
+      let(:id3) { double(Encoding::Id3).as_null_object }
 
       before do
-        Configuration.stub(:new).and_return(configuration)
-        configuration.stub(:applied?).and_return(true)
-        Encoding::Id3.stub(:new).and_return(id3)
+        allow(Configuration).to receive(:new).and_return(configuration)
+        allow(configuration).to receive(:applied?).and_return(true)
+        allow(Encoding::Id3).to receive(:new).and_return(id3)
       end
 
       it "creates vbr info" do
-        Encoding::Id3.should_receive(:new).with(configuration)
+        expect(Encoding::Id3).to receive(:new).with(configuration)
         encoder.id3v1 { }
       end
 
       context "v1" do
         it "creates the id3v1 frame" do
-          id3.should_receive(:v1)
+          expect(id3).to receive(:v1)
           encoder.id3v1 { }
         end
 
         it "yields the vbr frame" do
-          mp3_data = stub
-          id3.stub(:v1).and_return(mp3_data)
+          mp3_data = double("mp3_data")
+          allow(id3).to receive(:v1).and_return(mp3_data)
 
           expect { |block|
             encoder.id3v1(&block)
@@ -357,21 +357,21 @@ module LAME
         end
 
         it "returns the vbr frame if no block was given" do
-          mp3_data = stub
-          id3.stub(:v1).and_return(mp3_data)
-          encoder.id3v1.should eql mp3_data
+          mp3_data = double("mp3_data")
+          allow(id3).to receive(:v1).and_return(mp3_data)
+          expect(encoder.id3v1).to eql mp3_data
         end
       end
 
       context "v2" do
         it "creates the id3v2 frame" do
-          id3.should_receive(:v2)
+          expect(id3).to receive(:v2)
           encoder.id3v2 { }
         end
 
         it "yields the vbr frame" do
-          mp3_data = stub
-          id3.stub(:v2).and_return(mp3_data)
+          mp3_data = double("mp3_data")
+          allow(id3).to receive(:v2).and_return(mp3_data)
 
           expect { |block|
             encoder.id3v2(&block)
@@ -379,9 +379,9 @@ module LAME
         end
 
         it "returns the vbr frame if no block was given" do
-          mp3_data = stub
-          id3.stub(:v2).and_return(mp3_data)
-          encoder.id3v2.should eql mp3_data
+          mp3_data = double("mp3_data")
+          allow(id3).to receive(:v2).and_return(mp3_data)
+          expect(encoder.id3v2).to eql mp3_data
         end
       end
     end

data/spec/encoding/flusher_spec.rb

@@ -4,42 +4,42 @@ module LAME
   module Encoding
     describe Flusher do
 
-      let(:global_flags) { stub }
-      let(:configuration) { stub(Configuration, :global_flags => global_flags, :framesize => 1152, :output_buffer_size => 8640) }
+      let(:global_flags) { double("global_flags") }
+      let(:configuration) { double(Configuration, :global_flags => global_flags, :framesize => 1152, :output_buffer_size => 8640) }
 
       subject(:flusher) { Flusher.new(configuration) }
 
       it "creates output buffer" do
-        LAME.stub(:lame_encode_flush).and_return(0)
+        allow(LAME).to receive(:lame_encode_flush).and_return(0)
 
-        Buffer.should_receive(:create_empty).with(:uchar, 8640).and_return(stub.as_null_object)
+        expect(Buffer).to receive(:create_empty).with(:uchar, 8640).and_return(double.as_null_object)
 
         flusher.flush
       end
 
       it "flushes" do
-        output_stub = stub("output", :get_bytes => [])
-        Buffer.stub(:create_empty).with(:uchar, 8640).and_return(output_stub)
+        output_double = double("output", :get_bytes => [])
+        allow(Buffer).to receive(:create_empty).with(:uchar, 8640).and_return(output_double)
 
-        LAME.should_receive(:lame_encode_flush) do |flags, buffer, buffer_size|
-          flags.should       eql global_flags
-          buffer.should      eql output_stub
-          buffer_size.should eql 8640
+        expect(LAME).to receive(:lame_encode_flush) do |flags, buffer, buffer_size|
+          expect(flags).to       eql global_flags
+          expect(buffer).to      eql output_double
+          expect(buffer_size).to eql 8640
         end
 
         flusher.flush
       end
 
       it "returns the flushed data" do
-        LAME.stub(:lame_encode_flush).and_return(512)
+        allow(LAME).to receive(:lame_encode_flush).and_return(512)
 
-        mp3_data = stub
-        output = stub
-        output.stub(:get_bytes).with(0, 512).and_return(mp3_data)
+        mp3_data = double("mp3_data")
+        output = double("output")
+        allow(output).to receive(:get_bytes).with(0, 512).and_return(mp3_data)
 
-        Buffer.stub(:create_empty).with(:uchar, 8640).and_return(output)
+        allow(Buffer).to receive(:create_empty).with(:uchar, 8640).and_return(output)
 
-        flusher.flush.should eql mp3_data
+        expect(flusher.flush).to eql mp3_data
       end
 
     end

data/spec/encoding/id3_spec.rb

@@ -4,100 +4,100 @@ module LAME
   module Encoding
     describe Id3 do
 
-      let(:global_flags) { stub }
-      let(:configuration) { stub(Configuration, :global_flags => global_flags, :framesize => 1152, :output_buffer_size => 8640) }
+      let(:global_flags) { double }
+      let(:configuration) { double(Configuration, :global_flags => global_flags, :framesize => 1152, :output_buffer_size => 8640) }
 
       subject(:id3) { Id3.new(configuration) }
 
       describe "#v1" do
         it "creates empty and filled output buffer" do
-          LAME.stub(:lame_get_id3v1_tag).and_return(1024, 1024)
+          allow(LAME).to receive(:lame_get_id3v1_tag).and_return(1024, 1024)
 
           # Determine size
-          Buffer.should_receive(:create_empty).with(:uchar, 0).and_return(stub.as_null_object)
+          expect(Buffer).to receive(:create_empty).with(:uchar, 0).and_return(double.as_null_object)
 
           # Actual tag
-          Buffer.should_receive(:create_empty).with(:uchar, 1024).and_return(stub.as_null_object)
+          expect(Buffer).to receive(:create_empty).with(:uchar, 1024).and_return(double.as_null_object)
 
           id3.v1
         end
 
         it "creates tag" do
           # Determine size
-          LAME.should_receive(:lame_get_id3v1_tag) do |flags, buffer, buffer_size|
-            flags.should       eql global_flags
-            buffer.size.should eql 0
-            buffer_size.should eql 0
+          expect(LAME).to receive(:lame_get_id3v1_tag) do |flags, buffer, buffer_size|
+            expect(flags).to       eql global_flags
+            expect(buffer.size).to eql 0
+            expect(buffer_size).to eql 0
             1024
           end
 
           # Get actual tag
-          LAME.should_receive(:lame_get_id3v1_tag) do |flags, buffer, buffer_size|
-            flags.should       eql global_flags
-            buffer.size.should eql 1024
-            buffer_size.should eql 1024
+          expect(LAME).to receive(:lame_get_id3v1_tag) do |flags, buffer, buffer_size|
+            expect(flags).to       eql global_flags
+            expect(buffer.size).to eql 1024
+            expect(buffer_size).to eql 1024
           end
 
           id3.v1
         end
 
         it "returns the id3 tag" do
-          LAME.stub(:lame_get_id3v1_tag).and_return(512, 512)
+          allow(LAME).to receive(:lame_get_id3v1_tag).and_return(512, 512)
 
-          mp3_data = stub
-          output = stub
-          output.stub(:get_bytes).with(0, 512).and_return(mp3_data)
+          mp3_data = double("mp3_data")
+          output = double("output")
+          allow(output).to receive(:get_bytes).with(0, 512).and_return(mp3_data)
 
-          Buffer.stub(:create_empty).with(:uchar, 0)
-          Buffer.stub(:create_empty).with(:uchar, 512).and_return(output)
+          allow(Buffer).to receive(:create_empty).with(:uchar, 0)
+          allow(Buffer).to receive(:create_empty).with(:uchar, 512).and_return(output)
 
-          id3.v1.should eql mp3_data
+          expect(id3.v1).to eql mp3_data
         end
       end
 
       describe "#v2" do
         it "creates empty and filled output buffer" do
-          LAME.stub(:lame_get_id3v2_tag).and_return(1024, 1024)
+          allow(LAME).to receive(:lame_get_id3v2_tag).and_return(1024, 1024)
 
           # Determine size
-          Buffer.should_receive(:create_empty).with(:uchar, 0).and_return(stub.as_null_object)
+          expect(Buffer).to receive(:create_empty).with(:uchar, 0).and_return(double.as_null_object)
 
           # Actual tag
-          Buffer.should_receive(:create_empty).with(:uchar, 1024).and_return(stub.as_null_object)
+          expect(Buffer).to receive(:create_empty).with(:uchar, 1024).and_return(double.as_null_object)
 
           id3.v2
         end
 
         it "creates tag" do
           # Determine size
-          LAME.should_receive(:lame_get_id3v2_tag) do |flags, buffer, buffer_size|
-            flags.should       eql global_flags
-            buffer.size.should eql 0
-            buffer_size.should eql 0
+          expect(LAME).to receive(:lame_get_id3v2_tag) do |flags, buffer, buffer_size|
+            expect(flags).to       eql global_flags
+            expect(buffer.size).to eql 0
+            expect(buffer_size).to eql 0
             1024
           end
 
           # Get actual tag
-          LAME.should_receive(:lame_get_id3v2_tag) do |flags, buffer, buffer_size|
-            flags.should       eql global_flags
-            buffer.size.should eql 1024
-            buffer_size.should eql 1024
+          expect(LAME).to receive(:lame_get_id3v2_tag) do |flags, buffer, buffer_size|
+            expect(flags).to       eql global_flags
+            expect(buffer.size).to eql 1024
+            expect(buffer_size).to eql 1024
           end
 
           id3.v2
         end
 
         it "returns the id3 tag" do
-          LAME.stub(:lame_get_id3v2_tag).and_return(512, 512)
+          allow(LAME).to receive(:lame_get_id3v2_tag).and_return(512, 512)
 
-          mp3_data = stub
-          output = stub
-          output.stub(:get_bytes).with(0, 512).and_return(mp3_data)
+          mp3_data = double("mp3_data")
+          output = double("output")
+          allow(output).to receive(:get_bytes).with(0, 512).and_return(mp3_data)
 
-          Buffer.stub(:create_empty).with(:uchar, 0)
-          Buffer.stub(:create_empty).with(:uchar, 512).and_return(output)
+          allow(Buffer).to receive(:create_empty).with(:uchar, 0)
+          allow(Buffer).to receive(:create_empty).with(:uchar, 512).and_return(output)
 
-          id3.v2.should eql mp3_data
+          expect(id3.v2).to eql mp3_data
         end
       end