lame 0.0.3 → 0.0.5

data/spec/configuration_spec.rb

@@ -4,84 +4,84 @@ module LAME
   describe Configuration do
 
     context "intialization" do
-      let(:global_flags) { stub }
+      let(:global_flags) { double("global_flags") }
 
       subject(:configuration) { Configuration.new(global_flags) }
 
       it "initializes with global flags" do
-        configuration.global_flags.should eql global_flags
+        expect(configuration.global_flags).to eql global_flags
       end
 
       it "initializes a AsmOptimization configuration object" do
-        Configuration::AsmOptimization.should_receive(:new).with(global_flags)
+        expect(Configuration::AsmOptimization).to receive(:new).with(global_flags)
         configuration.asm_optimization
       end
 
       it "memoizes one AsmOptimization configuration object" do
-        Configuration::AsmOptimization.stub(:new).and_return(stub)
-        Configuration::AsmOptimization.should_receive(:new).exactly(:once)
+        allow(Configuration::AsmOptimization).to receive(:new).and_return(double)
+        expect(Configuration::AsmOptimization).to receive(:new).exactly(:once)
         2.times { configuration.asm_optimization }
       end
 
       it "initializes a Id3 configuration object" do
-        Configuration::Id3.should_receive(:new).with(global_flags)
+        expect(Configuration::Id3).to receive(:new).with(global_flags)
         configuration.id3
       end
 
       it "memoizes one Id3 configuration object" do
-        Configuration::Id3.stub(:new).and_return(stub)
-        Configuration::Id3.should_receive(:new).exactly(:once)
+        allow(Configuration::Id3).to receive(:new).and_return(double)
+        expect(Configuration::Id3).to receive(:new).exactly(:once)
         2.times { configuration.id3 }
       end
 
       it "initializes a Quantization configuration object" do
-        Configuration::Quantization.should_receive(:new).with(global_flags)
+        expect(Configuration::Quantization).to receive(:new).with(global_flags)
         configuration.quantization
       end
 
       it "memoizes one Quantization configuration object" do
-        Configuration::Quantization.stub(:new).and_return(stub)
-        Configuration::Quantization.should_receive(:new).exactly(:once)
+        allow(Configuration::Quantization).to receive(:new).and_return(double)
+        expect(Configuration::Quantization).to receive(:new).exactly(:once)
         2.times { configuration.quantization }
       end
 
       it "initializes a VBR configuration object" do
-        Configuration::VBR.should_receive(:new).with(global_flags)
+        expect(Configuration::VBR).to receive(:new).with(global_flags)
         configuration.vbr
       end
 
       it "memoizes one VBR configuration object" do
-        Configuration::VBR.stub(:new).and_return(stub)
-        Configuration::VBR.should_receive(:new).exactly(:once)
+        allow(Configuration::VBR).to receive(:new).and_return(double)
+        expect(Configuration::VBR).to receive(:new).exactly(:once)
         2.times { configuration.vbr }
       end
 
       it "initializes a Filtering configuration object" do
-        Configuration::Filtering.should_receive(:new).with(global_flags)
+        expect(Configuration::Filtering).to receive(:new).with(global_flags)
         configuration.filtering
       end
 
       it "memoizes one Filtering configuration object" do
-        Configuration::Filtering.stub(:new).and_return(stub)
-        Configuration::Filtering.should_receive(:new).exactly(:once)
+        allow(Configuration::Filtering).to receive(:new).and_return(double)
+        expect(Configuration::Filtering).to receive(:new).exactly(:once)
         2.times { configuration.filtering }
       end
 
       it "initializes a PsychoAcoustics configuration object" do
-        Configuration::PsychoAcoustics.should_receive(:new).with(global_flags)
+        expect(Configuration::PsychoAcoustics).to receive(:new).with(global_flags)
         configuration.psycho_acoustics
       end
 
       it "memoizes one PsychoAcoustics configuration object" do
-        Configuration::PsychoAcoustics.stub(:new).and_return(stub)
-        Configuration::PsychoAcoustics.should_receive(:new).exactly(:once)
+        allow(Configuration::PsychoAcoustics).to receive(:new).and_return(double)
+        expect(Configuration::PsychoAcoustics).to receive(:new).exactly(:once)
         2.times { configuration.psycho_acoustics }
       end
 
       context "Id3" do
 
         it "initializes the Id3 tag" do
-          LAME.should_receive(:id3tag_init).with(global_flags)
+          expect(LAME).to receive(:id3tag_init).with(global_flags)
           Configuration::Id3.new(global_flags)
         end
 
@@ -89,17 +89,17 @@ module LAME
 
       describe "#apply! / #applied?" do
         it "is not applied by default" do
-          configuration.should_not be_applied
+          expect(configuration).not_to be_applied
         end
 
         it "applies the configuration" do
-          LAME.should_receive(:lame_init_params).with(global_flags)
+          expect(LAME).to receive(:lame_init_params).with(global_flags)
           configuration.apply!
-          configuration.should be_applied
+          expect(configuration).to be_applied
         end
 
         it "raises an error if configuration could not be applied" do
-          LAME.stub(:lame_init_params).and_return(-1)
+          allow(LAME).to receive(:lame_init_params).and_return(-1)
           expect {
             configuration.apply!
           }.to raise_error(ConfigurationError)
@@ -109,12 +109,12 @@ module LAME
       describe "#framesize" do
 
         it "gets framesize from LAME if configuration was applied" do
-          LAME.stub(:lame_init_params)
+          allow(LAME).to receive(:lame_init_params)
           configuration.apply!
 
-          LAME.stub(:lame_get_framesize).and_return(42)
-          LAME.should_receive(:lame_get_framesize).with(global_flags)
-          configuration.framesize.should eql 42
+          allow(LAME).to receive(:lame_get_framesize).and_return(42)
+          expect(LAME).to receive(:lame_get_framesize).with(global_flags)
+          expect(configuration.framesize).to eql 42
         end
 
         it "raises an error if configuration was not applied" do
@@ -124,12 +124,12 @@ module LAME
         end
 
         it "calculates the output buffer size based on the framesize" do
-          LAME.stub(:lame_init_params)
+          allow(LAME).to receive(:lame_init_params)
           configuration.apply!
 
-          LAME.stub(:lame_get_framesize).and_return(1152)
-          LAME.should_receive(:lame_get_framesize).with(global_flags)
-          configuration.output_buffer_size.should eql 8640
+          allow(LAME).to receive(:lame_get_framesize).and_return(1152)
+          expect(LAME).to receive(:lame_get_framesize).with(global_flags)
+          expect(configuration.output_buffer_size).to eql 8640
         end
 
       end
@@ -148,7 +148,7 @@ module LAME
     # 
     context "set/get delegation" do
 
-      let(:global_flags) { stub(GlobalFlags) }
+      let(:global_flags) { double(GlobalFlags) }
       subject(:configuration) { Configuration.new(global_flags) }
 
       context "basic fields" do
@@ -183,8 +183,8 @@ module LAME
         it { should delegate(:emphasis) }
 
         it "delegates #preset= to LAME.lame_set_preset" do
-          LAME.should_receive(:lame_set_preset).with(global_flags, anything)
-          configuration.preset = stub
+          expect(LAME).to receive(:lame_set_preset).with(global_flags, anything)
+          configuration.preset = double
         end
 
       end
@@ -193,17 +193,17 @@ module LAME
         subject(:asm_optimization) { configuration.asm_optimization }
 
         it "delegates #mmx to LAME.lame_set_asm_optimizations" do
-          LAME.should_receive(:lame_set_asm_optimizations).with(global_flags, :MMX, 1)
+          expect(LAME).to receive(:lame_set_asm_optimizations).with(global_flags, :MMX, 1)
           asm_optimization.mmx = true
         end
 
         it "delegates #amd_3dnow to LAME.lame_set_asm_optimizations" do
-          LAME.should_receive(:lame_set_asm_optimizations).with(global_flags, :AMD_3DNOW, 1)
+          expect(LAME).to receive(:lame_set_asm_optimizations).with(global_flags, :AMD_3DNOW, 1)
           asm_optimization.amd_3dnow = true
         end
 
         it "delegates #sse to LAME.lame_set_asm_optimizations" do
-          LAME.should_receive(:lame_set_asm_optimizations).with(global_flags, :SSE, 1)
+          expect(LAME).to receive(:lame_set_asm_optimizations).with(global_flags, :SSE, 1)
           asm_optimization.sse = true
         end
       end
@@ -215,37 +215,37 @@ module LAME
         it { should delegate(:write_automatic).to(:write_id3tag_automatic) }
 
         before do
-          LAME.stub(:id3tag_init)
+          allow(LAME).to receive(:id3tag_init)
         end
 
         it "delegates #v2= to LAME.id3tag_add_v2" do
-          LAME.should_receive(:id3tag_add_v2).with(global_flags)
+          expect(LAME).to receive(:id3tag_add_v2).with(global_flags)
           id3.v2 = true
         end
 
         it "delegates #v1_only= to LAME.id3tag_v1_only" do
-          LAME.should_receive(:id3tag_v1_only).with(global_flags)
+          expect(LAME).to receive(:id3tag_v1_only).with(global_flags)
           id3.v1_only = true
         end
 
         it "delegates #v2_only= to LAME.id3tag_v2_only" do
-          LAME.should_receive(:id3tag_v2_only).with(global_flags)
+          expect(LAME).to receive(:id3tag_v2_only).with(global_flags)
           id3.v2_only = true
         end
 
         it "delegates #v1_space= to LAME.id3tag_v1_space" do
-          LAME.should_receive(:id3tag_space_v1).with(global_flags)
+          expect(LAME).to receive(:id3tag_space_v1).with(global_flags)
           id3.v1_space = true
         end
 
         it "delegates #v2_padding= to LAME.id3tag_pad_v2" do
-          LAME.should_receive(:id3tag_pad_v2).with(global_flags)
+          expect(LAME).to receive(:id3tag_pad_v2).with(global_flags)
           id3.v2_padding = true
         end
 
         it "delegates #v2_padding_size= to LAME.id3tag_set_pad" do
-          value = stub
-          LAME.should_receive(:id3tag_set_pad).with(global_flags, value)
+          value = double
+          expect(LAME).to receive(:id3tag_set_pad).with(global_flags, value)
           id3.v2_padding_size = value
         end
 
@@ -253,10 +253,10 @@ module LAME
         [ :title, :artist, :album, :year, :comment ].each do |field|
 
           it "sets the #{field} with string buffer" do
-            LAME.should_receive(:"id3tag_set_#{field}") do |flags, string_buffer|
-              flags.should eql global_flags
-              string_buffer.should be_a(::FFI::MemoryPointer)
-              string_buffer.get_string(0).should eql "Some #{field}"
+            expect(LAME).to receive(:"id3tag_set_#{field}") do |flags, string_buffer|
+              expect(flags).to eql global_flags
+              expect(string_buffer).to be_a(::FFI::MemoryPointer)
+              expect(string_buffer.get_string(0)).to eql "Some #{field}"
             end
             id3.send(:"#{field}=", "Some #{field}")
           end
@@ -264,37 +264,37 @@ module LAME
         end
 
         it "sets the track" do
-          LAME.should_receive(:"id3tag_set_track") do |flags, value|
-            flags.should eql global_flags
-            value.should eql 42
+          expect(LAME).to receive(:"id3tag_set_track") do |flags, value|
+            expect(flags).to eql global_flags
+            expect(value).to eql 42
           end
           id3.track = 42
         end
 
         it "sets the genre by name" do
-          LAME.should_receive(:id3tag_set_genre) do |flags, value|
-            flags.should eql global_flags
-            value.should be_a(::FFI::MemoryPointer)
-            value.get_string(0).should eql "147"
+          expect(LAME).to receive(:id3tag_set_genre) do |flags, value|
+            expect(flags).to eql global_flags
+            expect(value).to be_a(::FFI::MemoryPointer)
+            expect(value.get_string(0)).to eql "147"
           end
           id3.genre = "SynthPop"
         end
 
         it "sets the genre by id" do
-          LAME.should_receive(:id3tag_set_genre) do |flags, value|
-            flags.should eql global_flags
-            value.should be_a(::FFI::MemoryPointer)
-            value.get_string(0).should eql "81"
+          expect(LAME).to receive(:id3tag_set_genre) do |flags, value|
+            expect(flags).to eql global_flags
+            expect(value).to be_a(::FFI::MemoryPointer)
+            expect(value.get_string(0)).to eql "81"
           end
 
           id3.genre = 81
         end
 
         it "sets non-standard genre name" do
-          LAME.should_receive(:id3tag_set_genre) do |flags, value|
-            flags.should eql global_flags
-            value.should be_a(::FFI::MemoryPointer)
-            value.get_string(0).should eql "Ruby FFI Rock"
+          expect(LAME).to receive(:id3tag_set_genre) do |flags, value|
+            expect(flags).to eql global_flags
+            expect(value).to be_a(::FFI::MemoryPointer)
+            expect(value.get_string(0)).to eql "Ruby FFI Rock"
           end
           id3.genre = "Ruby FFI Rock"
         end
@@ -312,23 +312,23 @@ module LAME
         it { should delegate(:msfix) }
 
         it "delegates #reservoir= to LAME.lame_set_disable_reservoir" do
-          LAME.should_receive(:lame_set_disable_reservoir).with(global_flags, 1)
+          expect(LAME).to receive(:lame_set_disable_reservoir).with(global_flags, 1)
           quantization.reservoir = false
         end
 
         it "delegates #reservoir to LAME.lame_get_disable_reservoir" do
-          LAME.should_receive(:lame_get_disable_reservoir).with(global_flags)
+          expect(LAME).to receive(:lame_get_disable_reservoir).with(global_flags)
           quantization.reservoir
         end
 
         it "delegates #reservoir? to LAME.lame_get_disable_reservoir" do
-          LAME.should_receive(:lame_get_disable_reservoir).with(global_flags)
+          expect(LAME).to receive(:lame_get_disable_reservoir).with(global_flags)
           quantization.reservoir?
         end
 
         it "converts the return value 0 for #reservoir? to false" do
-          LAME.stub(:lame_get_disable_reservoir).and_return(0)
-          quantization.reservoir?.should be_false
+          allow(LAME).to receive(:lame_get_disable_reservoir).and_return(0)
+          expect(quantization.reservoir?).to be_falsy
         end
       end
 
@@ -365,23 +365,23 @@ module LAME
         it { should delegate(:athaa_sensitivity) }
 
         it "delegates #ath= to LAME.lame_set_noATH" do
-          LAME.should_receive(:lame_set_noATH).with(global_flags, 1)
+          expect(LAME).to receive(:lame_set_noATH).with(global_flags, 1)
           psycho_acoustics.ath = false
         end
 
         it "delegates #ath to LAME.lame_get_noATH" do
-          LAME.should_receive(:lame_get_noATH).with(global_flags)
+          expect(LAME).to receive(:lame_get_noATH).with(global_flags)
           psycho_acoustics.ath
         end
 
         it "delegates #ath? to LAME.lame_get_noATH" do
-          LAME.should_receive(:lame_get_noATH).with(global_flags)
+          expect(LAME).to receive(:lame_get_noATH).with(global_flags)
           psycho_acoustics.ath?
         end
 
         it "converts the return value 0 for #ath? to true" do
-          LAME.stub(:lame_get_noATH).and_return(0)
-          psycho_acoustics.ath?.should be_true
+          allow(LAME).to receive(:lame_get_noATH).and_return(0)
+          expect(psycho_acoustics.ath?).to be_truthy
         end
       end
 

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