lame 0.0.3 → 0.0.4

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
 

data/spec/encoding/interleaved_buffer_encoder_spec.rb

@@ -7,42 +7,42 @@ module LAME
       # stubbing galore!
 
       let(:framesize) { 1152 }
-      let(:samples) { stub(:size => framesize*2) }
-      let(:global_flags) { stub }
-      let(:configuration) { stub(Configuration, :global_flags => global_flags, :framesize => framesize, :output_buffer_size => 8640) }
+      let(:samples) { double("samples", :size => framesize*2) }
+      let(:global_flags) { double("global_flags") }
+      let(:configuration) { double(Configuration, :global_flags => global_flags, :framesize => framesize, :output_buffer_size => 8640) }
 
       subject(:encoder) { described_class.new(configuration) }
 
       it "creates input buffers" do
-        LAME.stub(lame_function).and_return(0)
+        allow(LAME).to receive(lame_function).and_return(0)
 
-        Buffer.should_receive(:create).with(data_type, samples)
+        expect(Buffer).to receive(:create).with(data_type, samples)
 
         encoder.encode_frame(samples)
       end
 
       it "creates output buffer" do
-        LAME.stub(lame_function).and_return(0)
+        allow(LAME).to receive(lame_function).and_return(0)
 
-        Buffer.stub(:create)
-        Buffer.should_receive(:create_empty).with(:uchar, 8640).and_return(stub.as_null_object)
+        allow(Buffer).to receive(:create)
+        expect(Buffer).to receive(:create_empty).with(:uchar, 8640).and_return(double.as_null_object)
 
         encoder.encode_frame(samples)
       end
 
       it "encodes the input" do
-        samples_stub = stub("samples")
-        output_stub = stub("output", :get_bytes => [])
+        samples_stub = double("samples")
+        output_stub = double("output", :get_bytes => [])
 
-        Buffer.stub(:create).with(data_type, samples).and_return(samples_stub)
-        Buffer.stub(:create_empty).with(:uchar, 8640).and_return(output_stub)
+        allow(Buffer).to receive(:create).with(data_type, samples).and_return(samples_stub)
+        allow(Buffer).to receive(:create_empty).with(:uchar, 8640).and_return(output_stub)
 
-        LAME.should_receive(lame_function) do |flags, interleaved_buffer, framesize, output, output_size|
-          flags.should               eql global_flags
-          interleaved_buffer.should  eql samples_stub
-          framesize.should           eql 1152
-          output.should              eql output_stub
-          output_size.should         eql 8640
+        expect(LAME).to receive(lame_function) do |flags, interleaved_buffer, framesize, output, output_size|
+          expect(flags).to               eql global_flags
+          expect(interleaved_buffer).to  eql samples_stub
+          expect(framesize).to           eql 1152
+          expect(output).to              eql output_stub
+          expect(output_size).to         eql 8640
 
           0 # return value
         end
@@ -51,16 +51,16 @@ module LAME
       end
 
       it "returns the encoded data" do
-        LAME.stub(lame_function).and_return(512)
+        allow(LAME).to receive(lame_function).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)
-        Buffer.stub(:create_empty).with(:uchar, 8640).and_return(output)
+        allow(Buffer).to receive(:create)
+        allow(Buffer).to receive(:create_empty).with(:uchar, 8640).and_return(output)
 
-        encoder.encode_frame(samples).should eql mp3_data
+        expect(encoder.encode_frame(samples)).to eql mp3_data
       end
     end
 

data/spec/encoding/stereo_buffer_encoder_spec.rb

@@ -7,47 +7,47 @@ module LAME
       # stubbing galore!
 
       let(:framesize) { 1152 }
-      let(:left) { stub(:size => framesize) }
-      let(:right) { stub }
-      let(:global_flags) { stub }
-      let(:configuration) { stub(Configuration, :global_flags => global_flags, :framesize => framesize, :output_buffer_size => 8640) }
+      let(:left) { double("left", :size => framesize) }
+      let(:right) { double("right") }
+      let(:global_flags) { double("global_flags") }
+      let(:configuration) { double(Configuration, :global_flags => global_flags, :framesize => framesize, :output_buffer_size => 8640) }
 
       subject(:encoder) { described_class.new(configuration) }
 
       it "creates input buffers" do
-        LAME.stub(lame_function).and_return(0)
+        allow(LAME).to receive(lame_function).and_return(0)
 
-        Buffer.should_receive(:create).with(data_type, left)
-        Buffer.should_receive(:create).with(data_type, right)
+        expect(Buffer).to receive(:create).with(data_type, left)
+        expect(Buffer).to receive(:create).with(data_type, right)
 
         encoder.encode_frame(left, right)
       end
 
       it "creates output buffer" do
-        LAME.stub(lame_function).and_return(0)
+        allow(LAME).to receive(lame_function).and_return(0)
 
-        Buffer.stub(:create)
-        Buffer.should_receive(:create_empty).with(:uchar, 8640).and_return(stub.as_null_object)
+        allow(Buffer).to receive(:create)
+        expect(Buffer).to receive(:create_empty).with(:uchar, 8640).and_return(double.as_null_object)
 
         encoder.encode_frame(left, right)
       end
 
       it "encodes the input" do
-        left_stub = stub("left")
-        right_stub = stub("right")
-        output_stub = stub("output", :get_bytes => [])
-
-        Buffer.stub(:create).with(data_type, left).and_return(left_stub)
-        Buffer.stub(:create).with(data_type, right).and_return(right_stub)
-        Buffer.stub(:create_empty).with(:uchar, 8640).and_return(output_stub)
-
-        LAME.should_receive(lame_function) do |flags, left_buffer, right_buffer, framesize, output, output_size|
-          flags.should        eql global_flags
-          left_buffer.should  eql left_stub
-          right_buffer.should eql right_stub
-          framesize.should    eql 1152
-          output.should       eql output_stub
-          output_size.should  eql 8640
+        left_double = double("left")
+        right_double = double("right")
+        output_double = double("output", :get_bytes => [])
+
+        allow(Buffer).to receive(:create).with(data_type, left).and_return(left_double)
+        allow(Buffer).to receive(:create).with(data_type, right).and_return(right_double)
+        allow(Buffer).to receive(:create_empty).with(:uchar, 8640).and_return(output_double)
+
+        expect(LAME).to receive(lame_function) do |flags, left_buffer, right_buffer, framesize, output, output_size|
+          expect(flags).to        eql global_flags
+          expect(left_buffer).to  eql left_double
+          expect(right_buffer).to eql right_double
+          expect(framesize).to    eql 1152
+          expect(output).to       eql output_double
+          expect(output_size).to  eql 8640
 
           0 # return value
         end
@@ -56,16 +56,16 @@ module LAME
       end
 
       it "returns the encoded data" do
-        LAME.stub(lame_function).and_return(512)
+        allow(LAME).to receive(lame_function).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)
-        Buffer.stub(:create_empty).with(:uchar, 8640).and_return(output)
+        allow(Buffer).to receive(:create)
+        allow(Buffer).to receive(:create_empty).with(:uchar, 8640).and_return(output)
 
-        encoder.encode_frame(left, right).should eql mp3_data
+        expect(encoder.encode_frame(left, right)).to eql mp3_data
       end
     end
 
@@ -85,7 +85,8 @@ module LAME
 
     describe LongBufferEncoder do
       it_should_behave_like "a stereo buffer encoder" do
-        let(:data_type) { :long }
+        # can be either int32 or int64 depending on system architecture
+        let(:data_type) { :"int#{::LAME::FFI::LONG_SIZE}" }
         let(:lame_function) { :lame_encode_buffer_long2 }
       end
     end

data/spec/encoding/vbr_info_spec.rb

@@ -4,42 +4,42 @@ module LAME
   module Encoding
     describe VBRInfo 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(:vbr_info) { VBRInfo.new(configuration) }
 
       it "creates output buffer" do
-        LAME.stub(:lame_get_lametag_frame).and_return(0)
+        allow(LAME).to receive(:lame_get_lametag_frame).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)
 
         vbr_info.frame
       end
 
       it "cretes the vbr frame" 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_get_lametag_frame) 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_get_lametag_frame) do |flags, buffer, buffer_size|
+          expect(flags).to       eql global_flags
+          expect(buffer).to      eql output_double
+          expect(buffer_size).to eql 8640
         end
 
         vbr_info.frame
       end
 
       it "returns the vbr frame" do
-        LAME.stub(:lame_get_lametag_frame).and_return(512)
+        allow(LAME).to receive(:lame_get_lametag_frame).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)
 
-        vbr_info.frame.should eql mp3_data
+        expect(vbr_info.frame).to eql mp3_data
       end
 
     end

data/spec/ffi/decode_flags_spec.rb

@@ -1,14 +1,15 @@
 module LAME
+
   describe DecodeFlags do 
     it "initializes LAME" do
       pointer = ::FFI::Pointer.new(0)
-      LAME.should_receive(:hip_decode_init).and_return(pointer)
+      expect(LAME).to receive(:hip_decode_init).and_return(pointer)
       DecodeFlags.new
     end
 
     it "closes the LAME struct pointer" do
       pointer = ::FFI::Pointer.new(0)
-      LAME.should_receive(:hip_decode_exit).with(pointer)
+      expect(LAME).to receive(:hip_decode_exit).with(pointer)
       DecodeFlags.release(pointer)
     end
   end