lame 0.0.3 → 0.0.5

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
 
@@ -77,5 +77,12 @@ module LAME
         let(:lame_function) { :lame_encode_buffer_interleaved_ieee_float }
       end
     end
+
+    describe InterleavedIntBufferEncoder do
+      it_should_behave_like "a interleaved buffer encoder" do
+        let(:data_type) { :int }
+        let(:lame_function) { :lame_encode_buffer_interleaved_int }
+      end
+    end
   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

data/spec/ffi/encoding_spec.rb

@@ -14,11 +14,11 @@ module LAME
     context "initialization" do
 
       it "initializes the parameters" do
-        LAME.lame_init_params(@flags_pointer).should eql 0
+        expect(LAME.lame_init_params(@flags_pointer)).to eql 0
       end
 
       it "inits the bitstream" do
-        LAME.lame_init_bitstream(@flags_pointer).should eql 0
+        expect(LAME.lame_init_bitstream(@flags_pointer)).to eql 0
       end
 
     end
@@ -45,7 +45,7 @@ module LAME
 
           it "encodes" do
             return_code = LAME.lame_encode_buffer(@flags_pointer, input_buffer_left, input_buffer_right, input_buffer_size, output_buffer, output_buffer_size)
-            return_code.should >= 0
+            expect(return_code).to be >= 0
           end
         end
 
@@ -54,7 +54,7 @@ module LAME
 
           it "encodes" do
             return_code = LAME.lame_encode_buffer_float(@flags_pointer, input_buffer_left, input_buffer_right, input_buffer_size, output_buffer, output_buffer_size)
-            return_code.should >= 0
+            expect(return_code).to be >= 0
           end
         end
 
@@ -63,7 +63,7 @@ module LAME
 
           it "encodes" do
             return_code = LAME.lame_encode_buffer_ieee_float(@flags_pointer, input_buffer_left, input_buffer_right, input_buffer_size, output_buffer, output_buffer_size)
-            return_code.should >= 0
+            expect(return_code).to be >= 0
           end
         end
 
@@ -72,7 +72,7 @@ module LAME
 
           it "encodes" do
             return_code = LAME.lame_encode_buffer_ieee_double(@flags_pointer, input_buffer_left, input_buffer_right, input_buffer_size, output_buffer, output_buffer_size)
-            return_code.should >= 0
+            expect(return_code).to be >= 0
           end
         end
 
@@ -81,7 +81,7 @@ module LAME
 
           it "encodes" do
             return_code = LAME.lame_encode_buffer_long(@flags_pointer, input_buffer_left, input_buffer_right, input_buffer_size, output_buffer, output_buffer_size)
-            return_code.should >= 0
+            expect(return_code).to be >= 0
           end
         end
 
@@ -90,7 +90,7 @@ module LAME
 
           it "encodes" do
             return_code = LAME.lame_encode_buffer_long2(@flags_pointer, input_buffer_left, input_buffer_right, input_buffer_size, output_buffer, output_buffer_size)
-            return_code.should >= 0
+            expect(return_code).to be >= 0
           end
         end
 
@@ -99,7 +99,7 @@ module LAME
 
           it "encodes" do
             return_code = LAME.lame_encode_buffer_int(@flags_pointer, input_buffer_left, input_buffer_right, input_buffer_size, output_buffer, output_buffer_size)
-            return_code.should >= 0
+            expect(return_code).to be >= 0
           end
         end
 
@@ -110,7 +110,7 @@ module LAME
 
             it "encodes" do
               return_code = LAME.lame_encode_buffer_interleaved(@flags_pointer, input_buffer_interleaved, input_buffer_size, output_buffer, output_buffer_size)
-              return_code.should >= 0
+              expect(return_code).to be >= 0
             end
           end
 
@@ -119,7 +119,7 @@ module LAME
 
             it "encodes" do
               return_code = LAME.lame_encode_buffer_interleaved_ieee_float(@flags_pointer, input_buffer_interleaved, input_buffer_size, output_buffer, output_buffer_size)
-              return_code.should >= 0
+              expect(return_code).to be >= 0
             end
           end
 
@@ -128,7 +128,7 @@ module LAME
 
             it "encodes" do
               return_code = LAME.lame_encode_buffer_interleaved_ieee_double(@flags_pointer, input_buffer_interleaved, input_buffer_size, output_buffer, output_buffer_size)
-              return_code.should >= 0
+              expect(return_code).to be >= 0
             end
           end
 
@@ -140,14 +140,14 @@ module LAME
         let(:input_type) { :short }
 
         it "flushes" do
-          LAME.lame_encode_flush(@flags_pointer, output_buffer, output_buffer_size).should be >= 0
+          expect(LAME.lame_encode_flush(@flags_pointer, output_buffer, output_buffer_size)).to be >= 0
         end
 
         it "flushes nogap" do
           # encode something so the flush doesn't give an error
           LAME.lame_encode_buffer(@flags_pointer, input_buffer_left, input_buffer_right, input_buffer_size, output_buffer, output_buffer_size)
 
-          LAME.lame_encode_flush_nogap(@flags_pointer, output_buffer, output_buffer_size).should >= 0
+          expect(LAME.lame_encode_flush_nogap(@flags_pointer, output_buffer, output_buffer_size)).to be >= 0
         end
       end
 
@@ -165,7 +165,7 @@ module LAME
 
           frame_size = LAME.lame_get_lametag_frame(@flags_pointer, output_buffer, output_buffer_size)
           #p output_buffer.get_bytes(0, frame_size)
-          frame_size.should eql 417
+          expect(frame_size).to eql 417
         end
       end
 
@@ -182,7 +182,7 @@ module LAME
 
           bitrate_count = bitrate_count_ptr.read_array_of_int(14)
           # 9th = 128 (see below)
-          bitrate_count.should eql [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
+          expect(bitrate_count).to eql [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
         end
 
         it "has bitrate kbps" do
@@ -191,7 +191,7 @@ module LAME
 
           bitrate_kbps = bitrate_kbps_ptr.read_array_of_int(14)
           # 9th = 128 (see bitrate table, without 0)
-          bitrate_kbps.should eql [32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320]
+          expect(bitrate_kbps).to eql [32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320]
         end
 
         it "has stereo mode hist" do
@@ -200,11 +200,11 @@ module LAME
 
           stereo_mode_hist = stereo_mode_hist_ptr.read_array_of_int(4)
           # see lame.h for meaning
-          stereo_mode_hist.should eql [0, 0, 1, 0]
+          expect(stereo_mode_hist).to eql [0, 0, 1, 0]
         end
 
         it "has bitrate stereo mode hist" do
-          pending "multi-dimensional array"
+          skip "multi-dimensional array"
         end
 
         it "has block type hist" do
@@ -213,17 +213,17 @@ module LAME
 
           block_type_hist = block_type_hist_ptr.read_array_of_int(6)
           # see lame.h for meaning
-          block_type_hist.should eql [4, 0, 0, 0, 0, 4]
+          expect(block_type_hist).to eql [4, 0, 0, 0, 0, 4]
         end
 
         it "has bitrate block type hist" do
-          pending "multi-dimensional array"
+          skip "multi-dimensional array"
         end
       end
 
       context "closing" do
         it "closes" do
-          LAME.lame_close(@flags_pointer).should eql 0
+          expect(LAME.lame_close(@flags_pointer)).to eql 0
         end
       end
     end