mp3file 1.2.0 → 1.3.0

data/spec/mp3file/mp3_header_spec.rb

@@ -5,13 +5,13 @@ include CommonHelpers
 
 describe Mp3file::MP3Header do
   it "raises an error if the first byte isn't 255" do
-    lambda { Mp3file::MP3Header.new(create_io([ 0xAA, 0xF8, 0x10, 0x01 ])) }.
-      should(raise_error(Mp3file::InvalidMP3HeaderError))
+    expect { Mp3file::MP3Header.new(create_io([ 0xAA, 0xF8, 0x10, 0x01 ])) }.
+      to(raise_error(Mp3file::InvalidMP3HeaderError))
   end
 
   it "raises an error if the second sync byte is wrong" do
-    lambda { Mp3file::MP3Header.new(create_io([ 0xFF, 0xB8, 0x10, 0x01 ])) }.
-      should(raise_error(Mp3file::InvalidMP3HeaderError))
+    expect { Mp3file::MP3Header.new(create_io([ 0xFF, 0xB8, 0x10, 0x01 ])) }.
+      to(raise_error(Mp3file::InvalidMP3HeaderError))
   end
 
   describe "#version" do
@@ -21,13 +21,13 @@ describe Mp3file::MP3Header do
     ].each do |bytes, version|
       it "recognizes #{version}" do
         h = Mp3file::MP3Header.new(create_io(bytes))
-        h.version.should == version
+        expect(h.version).to eq(version)
       end
     end
 
     it "raises an error on an invalid version" do
-      lambda { Mp3file::MP3Header.new(create_io([ 0xFF, 0b1110_1010, 0x10, 0x01 ])) }.
-        should(raise_error(Mp3file::InvalidMP3HeaderError))
+      expect { Mp3file::MP3Header.new(create_io([ 0xFF, 0b1110_1010, 0x10, 0x01 ])) }.
+        to(raise_error(Mp3file::InvalidMP3HeaderError))
     end
   end
 
@@ -38,13 +38,13 @@ describe Mp3file::MP3Header do
     ].each do |bytes, layer|
       it "recognizes #{layer}" do
         h = Mp3file::MP3Header.new(create_io(bytes))
-        h.layer.should == layer
+        expect(h.layer).to eq(layer)
       end
     end
 
     it "raises an error on an invalid version" do
-      lambda { Mp3file::MP3Header.new(create_io([ 0xFF, 0b1111_1000, 0x10, 0x01 ])) }.
-        should(raise_error(Mp3file::InvalidMP3HeaderError))
+      expect { Mp3file::MP3Header.new(create_io([ 0xFF, 0b1111_1000, 0x10, 0x01 ])) }.
+        to(raise_error(Mp3file::InvalidMP3HeaderError))
     end
   end
 
@@ -75,18 +75,18 @@ describe Mp3file::MP3Header do
           it "detects #{br} kbps" do
             io = create_io([ 0xFF, byte2, (i + 1) << 4, 0x01 ])
             h = Mp3file::MP3Header.new(io)
-            h.bitrate.should == br * 1000
+            expect(h.bitrate).to eq(br * 1000)
           end
         end
 
         it "rejects a free bitrate" do
           io = create_io([ 0xFF, byte2, 0x00, 0x01 ])
-          lambda { Mp3file::MP3Header.new(io) }.should(raise_error(Mp3file::InvalidMP3HeaderError))
+          expect { Mp3file::MP3Header.new(io) }.to(raise_error(Mp3file::InvalidMP3HeaderError))
         end
 
         it "rejects a bad bitrate" do
           io = create_io([ 0xFF, byte2, 0xF0, 0x01 ])
-          lambda { Mp3file::MP3Header.new(io) }.should(raise_error(Mp3file::InvalidMP3HeaderError))
+          expect { Mp3file::MP3Header.new(io) }.to(raise_error(Mp3file::InvalidMP3HeaderError))
         end
       end
     end
@@ -102,13 +102,13 @@ describe Mp3file::MP3Header do
           it "detects #{sr} Hz" do
             io = create_io([ 0xFF, byte2, 0x10 + (i << 2), 0x01 ])
             h = Mp3file::MP3Header.new(io)
-            h.samplerate.should == sr
+            expect(h.samplerate).to eq(sr)
           end
         end
 
         it "rejects reserved samplerate values" do
           io = create_io([ 0xFF, byte2, 0x1C, 0x01 ])
-          lambda { Mp3file::MP3Header.new(io) }.should(raise_error(Mp3file::InvalidMP3HeaderError))
+          expect { Mp3file::MP3Header.new(io) }.to(raise_error(Mp3file::InvalidMP3HeaderError))
         end
       end
     end
@@ -118,13 +118,13 @@ describe Mp3file::MP3Header do
     it "detects if the frame is padded" do
       io = create_io([ 0xFF, 0xFB, 0b0001_1010, 0x01 ])
       h = Mp3file::MP3Header.new(io)
-      h.has_padding.should == true
+      expect(h.has_padding).to eq(true)
     end
 
     it "detects if the frame is not padded" do
       io = create_io([ 0xFF, 0xFB, 0b0001_1000, 0x01 ])
       h = Mp3file::MP3Header.new(io)
-      h.has_padding.should == false
+      expect(h.has_padding).to eq(false)
     end
   end
 
@@ -132,25 +132,25 @@ describe Mp3file::MP3Header do
     it "detects Stereo" do
       io = create_io([ 0xFF, 0xFB, 0x92, 0b0000_0001 ])
       h = Mp3file::MP3Header.new(io)
-      h.mode.should == 'Stereo'
+      expect(h.mode).to eq('Stereo')
     end
 
     it "detects Joint Stereo" do
       io = create_io([ 0xFF, 0xFB, 0x92, 0b0100_0001 ])
       h = Mp3file::MP3Header.new(io)
-      h.mode.should == 'Joint Stereo'
+      expect(h.mode).to eq('Joint Stereo')
     end
 
     it "detects Dual Channel" do
       io = create_io([ 0xFF, 0xFB, 0x92, 0b1000_0001 ])
       h = Mp3file::MP3Header.new(io)
-      h.mode.should == 'Dual Channel'
+      expect(h.mode).to eq('Dual Channel')
     end
 
     it "detects Mono" do
       io = create_io([ 0xFF, 0xFB, 0x92, 0b1100_0001 ])
       h = Mp3file::MP3Header.new(io)
-      h.mode.should == 'Mono'
+      expect(h.mode).to eq('Mono')
     end
   end
 
@@ -159,25 +159,25 @@ describe Mp3file::MP3Header do
       it "detects bands 4 to 31" do
         io = create_io([ 0xFF, 0xFE, 0x92, 0b0100_0001 ])
         h = Mp3file::MP3Header.new(io)
-        h.mode_extension.should == 'bands 4 to 31'
+        expect(h.mode_extension).to eq('bands 4 to 31')
       end
 
       it "detects bands 8 to 31" do
         io = create_io([ 0xFF, 0xFD, 0x92, 0b0101_0001 ])
         h = Mp3file::MP3Header.new(io)
-        h.mode_extension.should == 'bands 8 to 31'
+        expect(h.mode_extension).to eq('bands 8 to 31')
       end
 
       it "detects bands 12 to 31" do
         io = create_io([ 0xFF, 0xFE, 0x92, 0b0110_0001 ])
         h = Mp3file::MP3Header.new(io)
-        h.mode_extension.should == 'bands 12 to 31'
+        expect(h.mode_extension).to eq('bands 12 to 31')
       end
 
       it "detects bands 16 to 31" do
         io = create_io([ 0xFF, 0xFD, 0x92, 0b0111_0001 ])
         h = Mp3file::MP3Header.new(io)
-        h.mode_extension.should == 'bands 16 to 31'
+        expect(h.mode_extension).to eq('bands 16 to 31')
       end
     end
 
@@ -185,25 +185,25 @@ describe Mp3file::MP3Header do
       it "detects neither mode extension" do
         io = create_io([ 0xFF, 0xFB, 0x92, 0b0100_0001 ])
         h = Mp3file::MP3Header.new(io)
-        h.mode_extension.should == nil
+        expect(h.mode_extension).to eq(nil)
       end
 
       it "detects only Intensity Stereo" do
         io = create_io([ 0xFF, 0xFB, 0x92, 0b0101_0001 ])
         h = Mp3file::MP3Header.new(io)
-        h.mode_extension.should == 'Intensity Stereo'
+        expect(h.mode_extension).to eq('Intensity Stereo')
       end
 
       it "detects only M/S Stereo" do
         io = create_io([ 0xFF, 0xFB, 0x92, 0b0110_0001 ])
         h = Mp3file::MP3Header.new(io)
-        h.mode_extension.should == 'M/S Stereo'
+        expect(h.mode_extension).to eq('M/S Stereo')
       end
 
       it "detects both Intensity Stereo & M/S Stereo" do
         io = create_io([ 0xFF, 0xFB, 0x92, 0b0111_0001 ])
         h = Mp3file::MP3Header.new(io)
-        h.mode_extension.should == [ 'Intensity Stereo', 'M/S Stereo' ]
+        expect(h.mode_extension).to eq([ 'Intensity Stereo', 'M/S Stereo' ])
       end
     end
 
@@ -211,19 +211,19 @@ describe Mp3file::MP3Header do
       it "should return no mode extension for Stereo" do
         io = create_io([ 0xFF, 0xFE, 0x92, 0b0011_0001 ])
         h = Mp3file::MP3Header.new(io)
-        h.mode_extension.should == nil
+        expect(h.mode_extension).to eq(nil)
       end
 
       it "should return no mode extension for Dual Channel" do
         io = create_io([ 0xFF, 0xFD, 0x92, 0b1011_0001 ])
         h = Mp3file::MP3Header.new(io)
-        h.mode_extension.should == nil
+        expect(h.mode_extension).to eq(nil)
       end
 
       it "should return no mode extension for Mono" do
         io = create_io([ 0xFF, 0xFB, 0x92, 0b1111_0001 ])
         h = Mp3file::MP3Header.new(io)
-        h.mode_extension.should == nil
+        expect(h.mode_extension).to eq(nil)
       end
     end
   end
@@ -232,13 +232,13 @@ describe Mp3file::MP3Header do
     it "detects copyrighted material" do
       io = create_io([ 0xFF, 0xFB, 0x92, 0b0111_1001 ])
       h = Mp3file::MP3Header.new(io)
-      h.copyright.should == true
+      expect(h.copyright).to eq(true)
     end
 
     it "detects non-copyrighted material" do
       io = create_io([ 0xFF, 0xFB, 0x92, 0b0111_0001 ])
       h = Mp3file::MP3Header.new(io)
-      h.copyright.should == false
+      expect(h.copyright).to eq(false)
     end
   end
 
@@ -246,13 +246,13 @@ describe Mp3file::MP3Header do
     it "detects original material" do
       io = create_io([ 0xFF, 0xFB, 0x92, 0b0111_0101 ])
       h = Mp3file::MP3Header.new(io)
-      h.original.should == true
+      expect(h.original).to eq(true)
     end
 
     it "detects non-original material" do
       io = create_io([ 0xFF, 0xFB, 0x92, 0b0111_0001 ])
       h = Mp3file::MP3Header.new(io)
-      h.original.should == false
+      expect(h.original).to eq(false)
     end
   end
 
@@ -260,24 +260,24 @@ describe Mp3file::MP3Header do
     it "detects no emphasis" do
       io = create_io([ 0xFF, 0xFB, 0x92, 0b0111_0000 ])
       h = Mp3file::MP3Header.new(io)
-      h.emphasis.should == 'none'
+      expect(h.emphasis).to eq('none')
     end
 
     it "detects 50/15 ms" do
       io = create_io([ 0xFF, 0xFB, 0x92, 0b0111_0001 ])
       h = Mp3file::MP3Header.new(io)
-      h.emphasis.should == '50/15 ms'
+      expect(h.emphasis).to eq('50/15 ms')
     end
 
     it "raises an error on 2" do
       io = create_io([ 0xFF, 0xFB, 0x92, 0b0111_0010 ])
-      lambda { Mp3file::MP3Header.new(io) }.should(raise_error(Mp3file::InvalidMP3HeaderError))
+      expect { Mp3file::MP3Header.new(io) }.to(raise_error(Mp3file::InvalidMP3HeaderError))
     end
 
     it "detects CCIT J.17" do
       io = create_io([ 0xFF, 0xFB, 0x92, 0b0111_0011 ])
       h = Mp3file::MP3Header.new(io)
-      h.emphasis.should == 'CCIT J.17'
+      expect(h.emphasis).to eq('CCIT J.17')
     end
   end
 
@@ -297,7 +297,7 @@ describe Mp3file::MP3Header do
       it("for #{name}, returns %d samples" % [ samples ]) do
         io = create_io([ 0xFF, byte2, 0x92, 0xC1 ])
         h = Mp3file::MP3Header.new(io)
-        h.samples.should == samples
+        expect(h.samples).to eq(samples)
       end
     end
   end
@@ -313,7 +313,7 @@ describe Mp3file::MP3Header do
       it "for #{name}, returns #{size} bytes" do
         io = create_io([ 0xFF, byte2, byte3, 0xC1 ])
         h = Mp3file::MP3Header.new(io)
-        h.frame_size.should == size
+        expect(h.frame_size).to eq(size)
       end
     end
   end
@@ -329,7 +329,24 @@ describe Mp3file::MP3Header do
       it "for #{name}, returns #{side_bytes} bytes" do
         io = create_io([ 0xFF, b2, b3, b4 ])
         h = Mp3file::MP3Header.new(io)
-        h.side_bytes.should == side_bytes
+        expect(h.side_bytes).to eq(side_bytes)
+      end
+    end
+  end
+
+  describe "#duration" do
+    combinations = [
+      [ "MPEG 1 Layer I 32 kHz",     0xFF, 0x1B, 384.0  / 32000.0 ],
+      [ "MPEG 1 Layer II 48 kHz",    0xFD, 0x34, 1152.0 / 48000.0 ],
+      [ "MPEG 1 Layer III 44.1 kHz", 0xFB, 0x53, 1152.0 / 44100.0 ],
+      [ "MPEG 2 Layer II 16 kHz",    0xF5, 0x48, 1152.0 / 16000.0 ],
+      [ "MPEG 2 Layer III 24 kHz",   0xF3, 0xD5, 576.0  / 24000.0 ],
+    ]
+    combinations.each do |name, b2, b3, duration|
+      it "for #{name}, returns #{duration} seconds" do
+        io = create_io([ 0xFF, b2, b3, 0xC1 ])
+        h = Mp3file::MP3Header.new(io)
+        expect(h.duration).to be_within(1e-5).of(duration)
       end
     end
   end

data/spec/mp3file/xing_header_spec.rb

@@ -6,52 +6,132 @@ include CommonHelpers
 describe Mp3file::XingHeader do
   it 'raises an error if the first 4 bytes don\'t say "Xing"' do
     io = StringIO.new("Ping\x00\x00\x00\x00")
-    lambda { Mp3file::XingHeader.new(io) }.should(raise_error(Mp3file::InvalidXingHeaderError))
+    expect { Mp3file::XingHeader.new(io) }.to(raise_error(Mp3file::InvalidXingHeaderError))
   end
 
   it 'raises an error if the next int is more than 15' do
     io = StringIO.new("Xing\x00\x00\x00\x10")
-    lambda { Mp3file::XingHeader.new(io) }.should(raise_error(Mp3file::InvalidXingHeaderError))
+    expect { Mp3file::XingHeader.new(io) }.to(raise_error(Mp3file::InvalidXingHeaderError))
   end
 
   describe "with no parts" do
     subject { Mp3file::XingHeader.new(StringIO.new("Xing\x00\x00\x00\x00")) }
-    its(:frames) { should == nil }
-    its(:bytes) { should == nil }
-    its(:toc) { should == nil }
-    its(:quality) { should == nil }
+
+    describe '#frames' do
+      subject { super().frames }
+      it { is_expected.to eq(nil) }
+    end
+
+    describe '#bytes' do
+      subject { super().bytes }
+      it { is_expected.to eq(nil) }
+    end
+
+    describe '#toc' do
+      subject { super().toc }
+      it { is_expected.to eq(nil) }
+    end
+
+    describe '#quality' do
+      subject { super().quality }
+      it { is_expected.to eq(nil) }
+    end
   end
 
   describe "with only a frame count" do
     subject { Mp3file::XingHeader.new(StringIO.new("Xing\x00\x00\x00\x01\x00\x00\x14\xFA")) }
-    its(:frames) { should == 5370 }
-    its(:bytes) { should == nil }
-    its(:toc) { should == nil }
-    its(:quality) { should == nil }
+
+    describe '#frames' do
+      subject { super().frames }
+      it { is_expected.to eq(5370) }
+    end
+
+    describe '#bytes' do
+      subject { super().bytes }
+      it { is_expected.to eq(nil) }
+    end
+
+    describe '#toc' do
+      subject { super().toc }
+      it { is_expected.to eq(nil) }
+    end
+
+    describe '#quality' do
+      subject { super().quality }
+      it { is_expected.to eq(nil) }
+    end
   end
 
   describe "with only a byte count" do
     subject { Mp3file::XingHeader.new(StringIO.new("Xing\x00\x00\x00\x02\x00\x00\x14\xFA")) }
-    its(:frames) { should == nil }
-    its(:bytes) { should == 5370 }
-    its(:toc) { should == nil }
-    its(:quality) { should == nil }
+
+    describe '#frames' do
+      subject { super().frames }
+      it { is_expected.to eq(nil) }
+    end
+
+    describe '#bytes' do
+      subject { super().bytes }
+      it { is_expected.to eq(5370) }
+    end
+
+    describe '#toc' do
+      subject { super().toc }
+      it { is_expected.to eq(nil) }
+    end
+
+    describe '#quality' do
+      subject { super().quality }
+      it { is_expected.to eq(nil) }
+    end
   end
 
   describe "with only a TOC" do
     subject { Mp3file::XingHeader.new(StringIO.new("Xing\x00\x00\x00\x04" + ("\x00" * 100))) }
-    its(:frames) { should == nil }
-    its(:bytes) { should == nil }
-    its(:toc) { should == [ 0 ] * 100 }
-    its(:quality) { should == nil }
+
+    describe '#frames' do
+      subject { super().frames }
+      it { is_expected.to eq(nil) }
+    end
+
+    describe '#bytes' do
+      subject { super().bytes }
+      it { is_expected.to eq(nil) }
+    end
+
+    describe '#toc' do
+      subject { super().toc }
+      it { is_expected.to eq([ 0 ] * 100) }
+    end
+
+    describe '#quality' do
+      subject { super().quality }
+      it { is_expected.to eq(nil) }
+    end
   end
 
   describe "with only a quality" do
     subject { Mp3file::XingHeader.new(StringIO.new("Xing\x00\x00\x00\x08\x00\x00\x00\x55")) }
-    its(:frames) { should == nil }
-    its(:bytes) { should == nil }
-    its(:toc) { should == nil }
-    its(:quality) { should == 85 }
+
+    describe '#frames' do
+      subject { super().frames }
+      it { is_expected.to eq(nil) }
+    end
+
+    describe '#bytes' do
+      subject { super().bytes }
+      it { is_expected.to eq(nil) }
+    end
+
+    describe '#toc' do
+      subject { super().toc }
+      it { is_expected.to eq(nil) }
+    end
+
+    describe '#quality' do
+      subject { super().quality }
+      it { is_expected.to eq(85) }
+    end
   end
 
   describe "with all four" do
@@ -67,9 +147,24 @@ describe Mp3file::XingHeader do
       Mp3file::XingHeader.new(StringIO.new(str))
     end
 
-    its(:frames) { should == 4977792 }
-    its(:bytes) { should == 1866672 }
-    its(:toc) { should == [ 0 ] * 100 }
-    its(:quality) { should == 85 }
+    describe '#frames' do
+      subject { super().frames }
+      it { is_expected.to eq(4977792) }
+    end
+
+    describe '#bytes' do
+      subject { super().bytes }
+      it { is_expected.to eq(1866672) }
+    end
+
+    describe '#toc' do
+      subject { super().toc }
+      it { is_expected.to eq([ 0 ] * 100) }
+    end
+
+    describe '#quality' do
+      subject { super().quality }
+      it { is_expected.to eq(85) }
+    end
   end
 end