lame 0.0.3 → 0.0.4

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

data/spec/ffi/global_flags_spec.rb

@@ -4,13 +4,13 @@ module LAME
   describe GlobalFlags do
     it "initializes LAME" do
       pointer = ::FFI::Pointer.new(0)
-      LAME.should_receive(:lame_init).and_return(pointer)
+      expect(LAME).to receive(:lame_init).and_return(pointer)
       GlobalFlags.new
     end
 
     it "closes the LAME struct pointer" do
       pointer = ::FFI::Pointer.new(0)
-      LAME.should_receive(:lame_close).with(pointer)
+      expect(LAME).to receive(:lame_close).with(pointer)
       GlobalFlags.release(pointer)
     end
   end
@@ -31,9 +31,9 @@ module LAME
         # puts format
       end
 
-      LAME.lame_set_msgf(@flags_pointer, callback).should eql 0
-      LAME.lame_set_errorf(@flags_pointer, callback).should eql 0
-      LAME.lame_set_debugf(@flags_pointer, callback).should eql 0
+      expect(LAME.lame_set_msgf(@flags_pointer, callback)).to eql 0
+      expect(LAME.lame_set_errorf(@flags_pointer, callback)).to eql 0
+      expect(LAME.lame_set_debugf(@flags_pointer, callback)).to eql 0
 
       LAME.lame_init_params(@flags_pointer)
 
@@ -48,93 +48,93 @@ module LAME
       end
 
       it "has a number of samples" do
-        LAME.should have_flag(:num_samples).with_value(2**32-1).for(@flags_pointer)
-        LAME.should be_able_to_set(:num_samples).to(1).for(@flags_pointer)
+        expect(LAME).to have_flag(:num_samples).with_value(2**32-1).for(@flags_pointer)
+        expect(LAME).to be_able_to_set(:num_samples).to(1).for(@flags_pointer)
       end
 
       it "has an input samplerate" do
-        LAME.should have_flag(:in_samplerate).with_value(44100).for(@flags_pointer)
-        LAME.should be_able_to_set(:in_samplerate).to(22050).for(@flags_pointer)
+        expect(LAME).to have_flag(:in_samplerate).with_value(44100).for(@flags_pointer)
+        expect(LAME).to be_able_to_set(:in_samplerate).to(22050).for(@flags_pointer)
       end
 
       it "has a number of channels" do
-        LAME.should have_flag(:num_channels).with_value(2).for(@flags_pointer)
-        LAME.should be_able_to_set(:num_channels).to(1).for(@flags_pointer)
+        expect(LAME).to have_flag(:num_channels).with_value(2).for(@flags_pointer)
+        expect(LAME).to be_able_to_set(:num_channels).to(1).for(@flags_pointer)
       end
 
       it "has a scale" do
-        LAME.should have_flag(:scale).with_value(0.95).for(@flags_pointer)
-        LAME.should be_able_to_set(:scale).to(2.0).for(@flags_pointer)
+        expect(LAME).to have_flag(:scale).with_value(0.95).for(@flags_pointer)
+        expect(LAME).to be_able_to_set(:scale).to(2.0).for(@flags_pointer)
       end
 
       it "has a scale_left" do
-        LAME.should have_flag(:scale_left).with_value(1.0).for(@flags_pointer)
-        LAME.should be_able_to_set(:scale_left).to(2.0).for(@flags_pointer)
+        expect(LAME).to have_flag(:scale_left).with_value(1.0).for(@flags_pointer)
+        expect(LAME).to be_able_to_set(:scale_left).to(2.0).for(@flags_pointer)
       end
 
       it "has a scale_right" do
-        LAME.should have_flag(:scale_right).with_value(1.0).for(@flags_pointer)
-        LAME.should be_able_to_set(:scale_right).to(2.0).for(@flags_pointer)
+        expect(LAME).to have_flag(:scale_right).with_value(1.0).for(@flags_pointer)
+        expect(LAME).to be_able_to_set(:scale_right).to(2.0).for(@flags_pointer)
       end
 
       it "has a output samplerate" do
-        LAME.should have_flag(:out_samplerate).with_value(44100).for(@flags_pointer)
-        LAME.should be_able_to_set(:out_samplerate).to(48000).for(@flags_pointer)
+        expect(LAME).to have_flag(:out_samplerate).with_value(44100).for(@flags_pointer)
+        expect(LAME).to be_able_to_set(:out_samplerate).to(48000).for(@flags_pointer)
       end
 
       it "has an analysis" do
-        LAME.should have_flag(:analysis).with_value(0).for(@flags_pointer)
-        LAME.should be_able_to_set(:analysis).to(1).for(@flags_pointer)
+        expect(LAME).to have_flag(:analysis).with_value(0).for(@flags_pointer)
+        expect(LAME).to be_able_to_set(:analysis).to(1).for(@flags_pointer)
       end
 
       it "has bWriteVbrTag" do
-        LAME.should have_flag(:bWriteVbrTag).with_value(1).for(@flags_pointer)
-        LAME.should be_able_to_set(:bWriteVbrTag).to(0).for(@flags_pointer)
+        expect(LAME).to have_flag(:bWriteVbrTag).with_value(1).for(@flags_pointer)
+        expect(LAME).to be_able_to_set(:bWriteVbrTag).to(0).for(@flags_pointer)
       end
 
       it "has decode only" do
-        LAME.should have_flag(:decode_only).with_value(0).for(@flags_pointer)
-        LAME.should be_able_to_set(:decode_only).to(1).for(@flags_pointer)
+        expect(LAME).to have_flag(:decode_only).with_value(0).for(@flags_pointer)
+        expect(LAME).to be_able_to_set(:decode_only).to(1).for(@flags_pointer)
       end
 
       it "has a quality" do
-        LAME.should have_flag(:quality).with_value(3).for(@flags_pointer)
-        LAME.should be_able_to_set(:quality).to(1).for(@flags_pointer)
+        expect(LAME).to have_flag(:quality).with_value(3).for(@flags_pointer)
+        expect(LAME).to be_able_to_set(:quality).to(1).for(@flags_pointer)
       end
 
       it "has a mode" do
-        LAME.should have_flag(:mode).with_value(:joint_stereo).for(@flags_pointer)
-        LAME.should be_able_to_set(:mode).to(:stereo).for(@flags_pointer)
+        expect(LAME).to have_flag(:mode).with_value(:joint_stereo).for(@flags_pointer)
+        expect(LAME).to be_able_to_set(:mode).to(:stereo).for(@flags_pointer)
       end
 
       it "has force ms" do
-        LAME.should have_flag(:force_ms).with_value(0).for(@flags_pointer)
-        LAME.should be_able_to_set(:force_ms).to(1).for(@flags_pointer)
+        expect(LAME).to have_flag(:force_ms).with_value(0).for(@flags_pointer)
+        expect(LAME).to be_able_to_set(:force_ms).to(1).for(@flags_pointer)
       end
 
       it "has free format" do
-        LAME.should have_flag(:free_format).with_value(0).for(@flags_pointer)
-        LAME.should be_able_to_set(:free_format).to(1).for(@flags_pointer)
+        expect(LAME).to have_flag(:free_format).with_value(0).for(@flags_pointer)
+        expect(LAME).to be_able_to_set(:free_format).to(1).for(@flags_pointer)
       end
 
       it "has find replay gain" do
-        LAME.should have_flag(:findReplayGain).with_value(0).for(@flags_pointer)
-        LAME.should be_able_to_set(:findReplayGain).to(1).for(@flags_pointer)
+        expect(LAME).to have_flag(:findReplayGain).with_value(0).for(@flags_pointer)
+        expect(LAME).to be_able_to_set(:findReplayGain).to(1).for(@flags_pointer)
       end
 
       it "has decode on the fly" do
-        LAME.should have_flag(:decode_on_the_fly).with_value(0).for(@flags_pointer)
-        LAME.should be_able_to_set(:decode_on_the_fly).to(1).for(@flags_pointer)
+        expect(LAME).to have_flag(:decode_on_the_fly).with_value(0).for(@flags_pointer)
+        expect(LAME).to be_able_to_set(:decode_on_the_fly).to(1).for(@flags_pointer)
       end
 
       it "has nogap total" do
-        LAME.should have_flag(:nogap_total).with_value(0).for(@flags_pointer)
-        LAME.should be_able_to_set(:nogap_total).to(1).for(@flags_pointer)
+        expect(LAME).to have_flag(:nogap_total).with_value(0).for(@flags_pointer)
+        expect(LAME).to be_able_to_set(:nogap_total).to(1).for(@flags_pointer)
       end
 
       it "has nogap current index" do
-        LAME.should have_flag(:nogap_currentindex).with_value(0).for(@flags_pointer)
-        LAME.should be_able_to_set(:nogap_currentindex).to(1).for(@flags_pointer)
+        expect(LAME).to have_flag(:nogap_currentindex).with_value(0).for(@flags_pointer)
+        expect(LAME).to be_able_to_set(:nogap_currentindex).to(1).for(@flags_pointer)
       end
 
       # lame_set_errorf
@@ -142,335 +142,335 @@ module LAME
       # lame_set_msgf
 
       it "has a brate" do
-        LAME.should have_flag(:brate).with_value(128).for(@flags_pointer)
-        LAME.should be_able_to_set(:brate).to(192).for(@flags_pointer)
+        expect(LAME).to have_flag(:brate).with_value(128).for(@flags_pointer)
+        expect(LAME).to be_able_to_set(:brate).to(192).for(@flags_pointer)
       end
 
       it "has a compression ratio" do
-        LAME.should have_flag(:compression_ratio).with_value(1).for(@flags_pointer)
-        #LAME.should be_able_to_set(:compression_ratio).to(11.025).for(@flags_pointer) # can't set it..?
+        expect(LAME).to have_flag(:compression_ratio).with_value(1).for(@flags_pointer)
+        #expect(LAME).to be_able_to_set(:compression_ratio).to(11.025).for(@flags_pointer) # can't set it..?
       end
 
       it "has a preset" do
-        LAME.lame_set_preset(@flags_pointer, :V0).should eql :V0
+        expect(LAME.lame_set_preset(@flags_pointer, :V0)).to eql :V0
       end
 
       it "sets asm optimizations" do
-        LAME.lame_set_asm_optimizations(@flags_pointer, :MMX, 1).should eql :MMX
+        expect(LAME.lame_set_asm_optimizations(@flags_pointer, :MMX, 1)).to eql :MMX
       end
 
       it "has a copyright mark" do
-        LAME.should have_flag(:copyright).with_value(0).for(@flags_pointer)
-        LAME.should be_able_to_set(:copyright).to(1).for(@flags_pointer)
+        expect(LAME).to have_flag(:copyright).with_value(0).for(@flags_pointer)
+        expect(LAME).to be_able_to_set(:copyright).to(1).for(@flags_pointer)
       end
 
       it "has an original mark" do
-        LAME.should have_flag(:original).with_value(1).for(@flags_pointer)
-        LAME.should be_able_to_set(:original).to(0).for(@flags_pointer)
+        expect(LAME).to have_flag(:original).with_value(1).for(@flags_pointer)
+        expect(LAME).to be_able_to_set(:original).to(0).for(@flags_pointer)
       end
 
       it "has error protection" do
-        LAME.should have_flag(:error_protection).with_value(0).for(@flags_pointer)
-        LAME.should be_able_to_set(:error_protection).to(1).for(@flags_pointer)
+        expect(LAME).to have_flag(:error_protection).with_value(0).for(@flags_pointer)
+        expect(LAME).to be_able_to_set(:error_protection).to(1).for(@flags_pointer)
       end
 
       it "has extension mark" do
-        LAME.should have_flag(:extension).with_value(0).for(@flags_pointer)
-        LAME.should be_able_to_set(:extension).to(1).for(@flags_pointer)
+        expect(LAME).to have_flag(:extension).with_value(0).for(@flags_pointer)
+        expect(LAME).to be_able_to_set(:extension).to(1).for(@flags_pointer)
       end
 
       it "has strict ISO" do
-        LAME.should have_flag(:strict_ISO).with_value(2).for(@flags_pointer) # ?
-        LAME.should be_able_to_set(:strict_ISO).to(1).for(@flags_pointer)
+        expect(LAME).to have_flag(:strict_ISO).with_value(2).for(@flags_pointer) # ?
+        expect(LAME).to be_able_to_set(:strict_ISO).to(1).for(@flags_pointer)
       end
 
       context "quantization/noise shaping" do
 
         it "has disable reservoir" do
-          LAME.should have_flag(:disable_reservoir).with_value(0).for(@flags_pointer)
-          LAME.should be_able_to_set(:disable_reservoir).to(1).for(@flags_pointer)
+          expect(LAME).to have_flag(:disable_reservoir).with_value(0).for(@flags_pointer)
+          expect(LAME).to be_able_to_set(:disable_reservoir).to(1).for(@flags_pointer)
         end
 
         it "has quant comp" do
-          LAME.should have_flag(:quant_comp).with_value(9).for(@flags_pointer)
-          LAME.should be_able_to_set(:quant_comp).to(11).for(@flags_pointer)
+          expect(LAME).to have_flag(:quant_comp).with_value(9).for(@flags_pointer)
+          expect(LAME).to be_able_to_set(:quant_comp).to(11).for(@flags_pointer)
         end
 
         it "has quant comp short" do
-          LAME.should have_flag(:quant_comp_short).with_value(9).for(@flags_pointer)
-          LAME.should be_able_to_set(:quant_comp_short).to(11).for(@flags_pointer)
+          expect(LAME).to have_flag(:quant_comp_short).with_value(9).for(@flags_pointer)
+          expect(LAME).to be_able_to_set(:quant_comp_short).to(11).for(@flags_pointer)
         end
 
         it "has experimentalX" do
-          LAME.should have_flag(:experimentalX).with_value(9).for(@flags_pointer)
-          LAME.should be_able_to_set(:experimentalX).to(11).for(@flags_pointer)
+          expect(LAME).to have_flag(:experimentalX).with_value(9).for(@flags_pointer)
+          expect(LAME).to be_able_to_set(:experimentalX).to(11).for(@flags_pointer)
         end
 
         it "has experimentalY" do
-          LAME.should have_flag(:experimentalY).with_value(0).for(@flags_pointer)
-          LAME.should be_able_to_set(:experimentalY).to(1).for(@flags_pointer)
+          expect(LAME).to have_flag(:experimentalY).with_value(0).for(@flags_pointer)
+          expect(LAME).to be_able_to_set(:experimentalY).to(1).for(@flags_pointer)
         end
 
         it "has experimentalZ" do
-          LAME.should have_flag(:experimentalZ).with_value(0).for(@flags_pointer)
-          LAME.should be_able_to_set(:experimentalZ).to(1).for(@flags_pointer)
+          expect(LAME).to have_flag(:experimentalZ).with_value(0).for(@flags_pointer)
+          expect(LAME).to be_able_to_set(:experimentalZ).to(1).for(@flags_pointer)
         end
 
         it "has exp nspsytune" do
-          LAME.should have_flag(:exp_nspsytune).with_value(1).for(@flags_pointer)
-          LAME.should be_able_to_set(:exp_nspsytune).to(0).for(@flags_pointer)
+          expect(LAME).to have_flag(:exp_nspsytune).with_value(1).for(@flags_pointer)
+          expect(LAME).to be_able_to_set(:exp_nspsytune).to(0).for(@flags_pointer)
         end
 
         it "has msfix" do
-          LAME.should have_flag(:msfix).with_value(1.95).for(@flags_pointer)
-          LAME.should be_able_to_set(:msfix).to(1.55).and_return(nil).for(@flags_pointer)
+          expect(LAME).to have_flag(:msfix).with_value(1.95).for(@flags_pointer)
+          expect(LAME).to be_able_to_set(:msfix).to(1.55).and_return(nil).for(@flags_pointer)
         end
       end
 
       context "VBR" do
         it "has VBR mode" do
-          LAME.should have_flag(:VBR).with_value(:vbr_off).for(@flags_pointer)
-          LAME.should be_able_to_set(:VBR).to(:vbr_mt).for(@flags_pointer)
+          expect(LAME).to have_flag(:VBR).with_value(:vbr_off).for(@flags_pointer)
+          expect(LAME).to be_able_to_set(:VBR).to(:vbr_mt).for(@flags_pointer)
         end
 
         it "has VBR q" do
-          LAME.should have_flag(:VBR_q).with_value(4).for(@flags_pointer)
-          LAME.should be_able_to_set(:VBR_q).to(5).for(@flags_pointer)
+          expect(LAME).to have_flag(:VBR_q).with_value(4).for(@flags_pointer)
+          expect(LAME).to be_able_to_set(:VBR_q).to(5).for(@flags_pointer)
         end
 
         it "has VBR quality" do
-          LAME.should have_flag(:VBR_quality).with_value(4.0).for(@flags_pointer)
-          LAME.should be_able_to_set(:VBR_quality).to(5.0).for(@flags_pointer)
+          expect(LAME).to have_flag(:VBR_quality).with_value(4.0).for(@flags_pointer)
+          expect(LAME).to be_able_to_set(:VBR_quality).to(5.0).for(@flags_pointer)
         end
 
         it "has VBR mean bitrate kbps" do
-          LAME.should have_flag(:VBR_mean_bitrate_kbps).with_value(128).for(@flags_pointer)
-          LAME.should be_able_to_set(:VBR_mean_bitrate_kbps).to(192).for(@flags_pointer)
+          expect(LAME).to have_flag(:VBR_mean_bitrate_kbps).with_value(128).for(@flags_pointer)
+          expect(LAME).to be_able_to_set(:VBR_mean_bitrate_kbps).to(192).for(@flags_pointer)
         end
 
         it "has VBR min bitrate kbps" do
-          LAME.should have_flag(:VBR_min_bitrate_kbps).with_value(0).for(@flags_pointer)
-          LAME.should be_able_to_set(:VBR_min_bitrate_kbps).to(128).for(@flags_pointer)
+          expect(LAME).to have_flag(:VBR_min_bitrate_kbps).with_value(0).for(@flags_pointer)
+          expect(LAME).to be_able_to_set(:VBR_min_bitrate_kbps).to(128).for(@flags_pointer)
         end
 
         it "has VBR max bitrate kbps" do
-          LAME.should have_flag(:VBR_max_bitrate_kbps).with_value(0).for(@flags_pointer)
-          LAME.should be_able_to_set(:VBR_max_bitrate_kbps).to(256).for(@flags_pointer)
+          expect(LAME).to have_flag(:VBR_max_bitrate_kbps).with_value(0).for(@flags_pointer)
+          expect(LAME).to be_able_to_set(:VBR_max_bitrate_kbps).to(256).for(@flags_pointer)
         end
 
         it "has VBR hard min bitrate kbps" do
-          LAME.should have_flag(:VBR_hard_min).with_value(0).for(@flags_pointer)
-          LAME.should be_able_to_set(:VBR_hard_min).to(1).for(@flags_pointer)
+          expect(LAME).to have_flag(:VBR_hard_min).with_value(0).for(@flags_pointer)
+          expect(LAME).to be_able_to_set(:VBR_hard_min).to(1).for(@flags_pointer)
         end
       end
 
       context "filtering control" do
         it "has lowpassfreq" do
-          LAME.should have_flag(:lowpassfreq).with_value(17000).for(@flags_pointer)
-          LAME.should be_able_to_set(:lowpassfreq).to(18000).for(@flags_pointer)
+          expect(LAME).to have_flag(:lowpassfreq).with_value(17000).for(@flags_pointer)
+          expect(LAME).to be_able_to_set(:lowpassfreq).to(18000).for(@flags_pointer)
         end
 
         it "has lowpasswidth" do
-          LAME.should have_flag(:lowpasswidth).with_value(-1).for(@flags_pointer)
-          LAME.should be_able_to_set(:lowpasswidth).to(200).for(@flags_pointer)
+          expect(LAME).to have_flag(:lowpasswidth).with_value(-1).for(@flags_pointer)
+          expect(LAME).to be_able_to_set(:lowpasswidth).to(200).for(@flags_pointer)
         end
 
         it "has highpassfreq" do
-          LAME.should have_flag(:highpassfreq).with_value(0).for(@flags_pointer)
-          LAME.should be_able_to_set(:highpassfreq).to(-1).for(@flags_pointer)
+          expect(LAME).to have_flag(:highpassfreq).with_value(0).for(@flags_pointer)
+          expect(LAME).to be_able_to_set(:highpassfreq).to(-1).for(@flags_pointer)
         end
 
         it "has highpasswidth" do
-          LAME.should have_flag(:highpasswidth).with_value(-1).for(@flags_pointer)
-          LAME.should be_able_to_set(:highpasswidth).to(200).for(@flags_pointer)
+          expect(LAME).to have_flag(:highpasswidth).with_value(-1).for(@flags_pointer)
+          expect(LAME).to be_able_to_set(:highpasswidth).to(200).for(@flags_pointer)
         end
       end
 
       context "psycho acoustics" do
         it "has ATHonly" do
-          LAME.should have_flag(:ATHonly).with_value(0).for(@flags_pointer)
-          LAME.should be_able_to_set(:ATHonly).to(1).for(@flags_pointer)
+          expect(LAME).to have_flag(:ATHonly).with_value(0).for(@flags_pointer)
+          expect(LAME).to be_able_to_set(:ATHonly).to(1).for(@flags_pointer)
         end
 
         it "has ATHshort" do
-          LAME.should have_flag(:ATHshort).with_value(0).for(@flags_pointer)
-          LAME.should be_able_to_set(:ATHshort).to(1).for(@flags_pointer)
+          expect(LAME).to have_flag(:ATHshort).with_value(0).for(@flags_pointer)
+          expect(LAME).to be_able_to_set(:ATHshort).to(1).for(@flags_pointer)
         end
 
         it "has noATH" do
-          LAME.should have_flag(:noATH).with_value(0).for(@flags_pointer)
-          LAME.should be_able_to_set(:noATH).to(1).for(@flags_pointer)
+          expect(LAME).to have_flag(:noATH).with_value(0).for(@flags_pointer)
+          expect(LAME).to be_able_to_set(:noATH).to(1).for(@flags_pointer)
         end
 
         it "has ATHtype" do
-          LAME.should have_flag(:ATHtype).with_value(4).for(@flags_pointer)
-          LAME.should be_able_to_set(:ATHtype).to(5).for(@flags_pointer)
+          expect(LAME).to have_flag(:ATHtype).with_value(4).for(@flags_pointer)
+          expect(LAME).to be_able_to_set(:ATHtype).to(5).for(@flags_pointer)
         end
 
         it "has ATHlower" do
-          LAME.should have_flag(:ATHlower).with_value(3.0).for(@flags_pointer)
-          LAME.should be_able_to_set(:ATHlower).to(4.0).for(@flags_pointer)
+          expect(LAME).to have_flag(:ATHlower).with_value(3.0).for(@flags_pointer)
+          expect(LAME).to be_able_to_set(:ATHlower).to(4.0).for(@flags_pointer)
         end
 
         it "has athaa type" do
-          LAME.should have_flag(:athaa_type).with_value(-1).for(@flags_pointer)
-          LAME.should be_able_to_set(:athaa_type).to(1).for(@flags_pointer)
+          expect(LAME).to have_flag(:athaa_type).with_value(-1).for(@flags_pointer)
+          expect(LAME).to be_able_to_set(:athaa_type).to(1).for(@flags_pointer)
         end
 
         it "has athaa sensitivity" do
-          LAME.should have_flag(:athaa_sensitivity).with_value(0.0).for(@flags_pointer)
-          LAME.should be_able_to_set(:athaa_sensitivity).to(1.0).for(@flags_pointer)
+          expect(LAME).to have_flag(:athaa_sensitivity).with_value(0.0).for(@flags_pointer)
+          expect(LAME).to be_able_to_set(:athaa_sensitivity).to(1.0).for(@flags_pointer)
         end
       end
 
       context "blocks" do
         it "has allow diff short" do
-          LAME.should have_flag(:allow_diff_short).with_value(0).for(@flags_pointer)
-          LAME.should be_able_to_set(:allow_diff_short).to(1).for(@flags_pointer)
+          expect(LAME).to have_flag(:allow_diff_short).with_value(0).for(@flags_pointer)
+          expect(LAME).to be_able_to_set(:allow_diff_short).to(1).for(@flags_pointer)
         end
 
         it "has useTemporal" do
-          LAME.should have_flag(:useTemporal).with_value(1).for(@flags_pointer)
-          LAME.should be_able_to_set(:useTemporal).to(0).for(@flags_pointer)
+          expect(LAME).to have_flag(:useTemporal).with_value(1).for(@flags_pointer)
+          expect(LAME).to be_able_to_set(:useTemporal).to(0).for(@flags_pointer)
         end
 
         it "has interChRatio" do
-          LAME.should have_flag(:interChRatio).with_value(0.0002).for(@flags_pointer)
-          LAME.should be_able_to_set(:interChRatio).to(0.0003).for(@flags_pointer)
+          expect(LAME).to have_flag(:interChRatio).with_value(0.0002).for(@flags_pointer)
+          expect(LAME).to be_able_to_set(:interChRatio).to(0.0003).for(@flags_pointer)
         end
 
         it "has no short blocks" do
-          LAME.should have_flag(:no_short_blocks).with_value(0).for(@flags_pointer)
-          LAME.should be_able_to_set(:no_short_blocks).to(1).for(@flags_pointer)
+          expect(LAME).to have_flag(:no_short_blocks).with_value(0).for(@flags_pointer)
+          expect(LAME).to be_able_to_set(:no_short_blocks).to(1).for(@flags_pointer)
         end
 
         it "has force short blocks" do
-          LAME.should have_flag(:force_short_blocks).with_value(0).for(@flags_pointer)
-          LAME.should be_able_to_set(:force_short_blocks).to(1).for(@flags_pointer)
+          expect(LAME).to have_flag(:force_short_blocks).with_value(0).for(@flags_pointer)
+          expect(LAME).to be_able_to_set(:force_short_blocks).to(1).for(@flags_pointer)
         end
 
         it "has emphasis" do
-          LAME.should have_flag(:emphasis).with_value(0).for(@flags_pointer)
-          LAME.should be_able_to_set(:emphasis).to(1).for(@flags_pointer)
+          expect(LAME).to have_flag(:emphasis).with_value(0).for(@flags_pointer)
+          expect(LAME).to be_able_to_set(:emphasis).to(1).for(@flags_pointer)
         end
       end
 
       context "internal variables" do
         it "has a version" do
-          LAME.should have_getter(:version).with_value(1).for(@flags_pointer)
+          expect(LAME).to have_getter(:version).with_value(1).for(@flags_pointer)
         end
 
         it "has encoder delay" do
-          LAME.should have_getter(:encoder_delay).with_value(576).for(@flags_pointer)
+          expect(LAME).to have_getter(:encoder_delay).with_value(576).for(@flags_pointer)
         end
 
         it "has encoder padding" do
-          LAME.should have_getter(:encoder_padding).with_value(0).for(@flags_pointer)
+          expect(LAME).to have_getter(:encoder_padding).with_value(0).for(@flags_pointer)
         end
 
         it "has framesize" do
-          LAME.should have_getter(:framesize).with_value(1152).for(@flags_pointer)
+          expect(LAME).to have_getter(:framesize).with_value(1152).for(@flags_pointer)
         end
 
         it "has mf samples to encode" do
-          LAME.should have_getter(:mf_samples_to_encode).with_value(1728).for(@flags_pointer)
+          expect(LAME).to have_getter(:mf_samples_to_encode).with_value(1728).for(@flags_pointer)
         end
 
         # mp3buffer (see below)
 
         it "has frameNum" do
-          LAME.should have_getter(:frameNum).with_value(0).for(@flags_pointer)
+          expect(LAME).to have_getter(:frameNum).with_value(0).for(@flags_pointer)
         end
 
         # unpredictable default value between versions:
         it "has totalframes" do
-          # LAME.should have_getter(:totalframes).with_value(3728272).for(@flags_pointer)
-          LAME.should have_getter(:totalframes).for(@flags_pointer)
+          # expect(LAME).to have_getter(:totalframes).with_value(3728272).for(@flags_pointer)
+          expect(LAME).to have_getter(:totalframes).for(@flags_pointer)
         end
 
         it "has RatioGain" do
-          LAME.should have_getter(:RadioGain).with_value(0).for(@flags_pointer)
+          expect(LAME).to have_getter(:RadioGain).with_value(0).for(@flags_pointer)
         end
 
         it "has AudiophileGain" do
-          LAME.should have_getter(:AudiophileGain).with_value(0).for(@flags_pointer)
+          expect(LAME).to have_getter(:AudiophileGain).with_value(0).for(@flags_pointer)
         end
 
         it "has PeakSample" do
-          LAME.should have_getter(:PeakSample).with_value(0.0).for(@flags_pointer)
+          expect(LAME).to have_getter(:PeakSample).with_value(0.0).for(@flags_pointer)
         end
 
         it "has noclipGainChange" do
-          LAME.should have_getter(:noclipGainChange).with_value(0).for(@flags_pointer)
+          expect(LAME).to have_getter(:noclipGainChange).with_value(0).for(@flags_pointer)
         end
 
         it "has noclipScale" do
-          LAME.should have_getter(:noclipScale).with_value(-1.0).for(@flags_pointer)
+          expect(LAME).to have_getter(:noclipScale).with_value(-1.0).for(@flags_pointer)
         end
       end
 
       context "version" do
         it "has a version" do
-          LAME.get_lame_version.should =~ /3\.\d\d\.\d/
+          expect(LAME.get_lame_version).to match /3\.\d\d\.\d/
         end
 
         it "has a short version" do
-          LAME.get_lame_short_version.should =~ /3\.\d\d\.\d/
+          expect(LAME.get_lame_short_version).to match /3\.\d\d\.\d/
         end
 
         it "has a very short version" do
-          LAME.get_lame_very_short_version.should =~ /LAME3\.\d\dr\d/
+          expect(LAME.get_lame_very_short_version).to match /LAME3\.\d\dr\d/
         end
 
         it "has a psy version" do
-          LAME.get_psy_version.should eql "1.0"
+          expect(LAME.get_psy_version).to eql "1.0"
         end
 
         it "has a url" do
-          LAME.get_lame_url.should eql "http://lame.sf.net"
+          expect(LAME.get_lame_url).to eql "http://lame.sf.net"
         end
 
         it "has os bitness" do
-          LAME.get_lame_os_bitness.should =~ /(32|64)bits/
+          expect(LAME.get_lame_os_bitness).to match /(32|64)bits/
         end
 
         context "numerical version" do
 
           let(:version) { LAME.get_lame_version_numerical(@flags_pointer) }
           it "has a major version" do
-            version[:major].should eql 3
-
+            expect(version[:major]).to eql 3
           end
+
           it "has a minor version" do
-            version[:minor].should eql 99
+            expect(version[:minor]).to eql 99
           end
 
           it "has a alpha version" do
-            version[:alpha].should eql 0
+            expect(version[:alpha]).to eql 0
           end
 
           it "has a beta version" do
-            version[:beta].should eql 0
+            expect(version[:beta]).to eql 0
           end
 
           it "has a psy_major version" do
-            version[:psy_major].should eql 1
+            expect(version[:psy_major]).to eql 1
           end
 
           it "has a psy_minor version" do
-            version[:psy_minor].should eql 0
+            expect(version[:psy_minor]).to eql 0
           end
 
           it "has a psy_alpha version" do
-            version[:psy_alpha].should eql 0
+            expect(version[:psy_alpha]).to eql 0
           end
 
           it "has a psy_beta version" do
-            version[:psy_beta].should eql 0
+            expect(version[:psy_beta]).to eql 0
           end
 
           it "has features" do
-            version[:features].should eql ""
+            expect(version[:features]).to eql ""
           end
         end
 
@@ -488,17 +488,19 @@ module LAME
         LAME.lame_set_errorf(@flags_pointer, callback)
         LAME.lame_init_params(@flags_pointer)
 
-        LAME.should have_getter(:size_mp3buffer).with_value(834).for(@flags_pointer)
+        expect(LAME).to have_getter(:size_mp3buffer).with_value(834).for(@flags_pointer)
       end
 
       it "prints config" do
-        pending "we need to be able to tweak logging to be able to test this"
-        LAME.lame_print_config(@flags_pointer)
+        skip "we need to be able to tweak logging to be able to test this" do
+          LAME.lame_print_config(@flags_pointer)
+        end
       end
 
       it "prints internals" do
-        pending "we need to be able to tweak logging to be able to test this"
-        LAME.lame_print_internals(@flags_pointer)
+        skip "we need to be able to tweak logging to be able to test this" do
+          LAME.lame_print_internals(@flags_pointer)
+        end
       end
 
     end
@@ -517,7 +519,7 @@ module LAME
           [0, 8, 16, 24, 32, 40, 48, 56, 64, -1, -1, -1, -1, -1, -1, -1]
         ]
 
-        table.should eql expected
+        expect(table).to eql expected
       end
 
       it "has the samplerate table" do
@@ -533,7 +535,7 @@ module LAME
           [11025, 12000, 8000, -1]
         ]
 
-        table.should eql expected
+        expect(table).to eql expected
       end
 
     end