id3tag 0.10.1 → 0.14.0

data/spec/lib/id3tag/id3_v2_frame_parser_spec.rb

@@ -1,32 +0,0 @@
-require "spec_helper"
-describe ID3Tag::ID3V2FrameParser do
-  subject { described_class.new(frame_bytes, tag_major_version) }
-
-  context "parsing v2.2.x tag" do
-    let(:tag_major_version) { 2 }
-    let(:frame_bytes) { "TP2\u0000\u0000\u0004\u0000ABC" + "TP1\u0000\u0000\u0004\u0000DEF" }
-    it "should fabricate frames" do
-      expect(ID3Tag::Frames::V2::FrameFabricator).to receive(:fabricate).with('TP2', "\u0000ABC", nil, 2).once
-      expect(ID3Tag::Frames::V2::FrameFabricator).to receive(:fabricate).with('TP1', "\u0000DEF", nil, 2).once
-      subject.frames
-    end
-  end
-  context "parsing v2.2.3 tag" do
-    let(:tag_major_version) { 3 }
-    let(:frame_bytes) { "TIT2\u0000\u0000\u0000\u0004\u0000\u0000\u0000ABC" + "TIT1\u0000\u0000\u0000\u0004\u0000\u0000\u0000DEF" }
-    it "should fabricate frames" do
-      expect(ID3Tag::Frames::V2::FrameFabricator).to receive(:fabricate).with('TIT2', "\u0000ABC", "\u0000\u0000", 3).once
-      expect(ID3Tag::Frames::V2::FrameFabricator).to receive(:fabricate).with('TIT1', "\u0000DEF", "\u0000\u0000", 3).once
-      subject.frames
-    end
-  end
-  context "parsing v2.4.x tag" do
-    let(:tag_major_version) { 4 }
-    let(:frame_bytes) { "TIT2\u0000\u0000\u0000\u0004\u0000\u0000\u0000ABC" + "TIT1\u0000\u0000\u0000\u0004\u0000\u0000\u0000DEF" }
-    it "should fabricate frames" do
-      expect(ID3Tag::Frames::V2::FrameFabricator).to receive(:fabricate).with('TIT2', "\u0000ABC", "\u0000\u0000", 4).once
-      expect(ID3Tag::Frames::V2::FrameFabricator).to receive(:fabricate).with('TIT1', "\u0000DEF", "\u0000\u0000", 4).once
-      subject.frames
-    end
-  end
-end

data/spec/lib/id3tag/id3_v2_tag_header_spec.rb

@@ -1,149 +0,0 @@
-require "spec_helper"
-
-describe ID3Tag::ID3v2TagHeader do
-  subject { described_class.new(header_data) }
-  
-  describe "#major_version_number" do
-    context "when first bit represent 3" do
-      let(:header_data) { "ID3\03\00..." }
-
-      describe '#major_version_number' do
-        subject { super().major_version_number }
-        it { is_expected.to eq(3) }
-      end
-    end
-  end
-
-  describe "#minor_version_number" do
-    context "when 2nd bit represent 2" do
-      let(:header_data) { "ID3\03\02..." }
-
-      describe '#minor_version_number' do
-        subject { super().minor_version_number }
-        it { is_expected.to eq(2) }
-      end
-    end
-  end
-
-  describe "#version_number" do
-    let(:header_data) { "ID3\02\03..." }
-
-    describe '#version_number' do
-      subject { super().version_number }
-      it { is_expected.to eq("2.3") }
-    end
-  end
-
-  describe "header flags" do
-    context "when flags bite is 0b10000000" do
-      let(:header_data) { "ID3\03\00#{0b10000000.chr}" }
-
-      describe '#unsynchronisation?' do
-        subject { super().unsynchronisation? }
-        it { is_expected.to eq(true) }
-      end
-
-      describe '#extended_header?' do
-        subject { super().extended_header? }
-        it { is_expected.to eq(false) }
-      end
-
-      describe '#experimental?' do
-        subject { super().experimental? }
-        it { is_expected.to eq(false) }
-      end
-
-      describe '#footer_present?' do
-        subject { super().footer_present? }
-        it { is_expected.to eq(false) }
-      end
-    end
-    context "when flags bite is 0b01000000" do
-      let(:header_data) { "ID3\03\00#{0b01000000.chr}" }
-
-      describe '#unsynchronisation?' do
-        subject { super().unsynchronisation? }
-        it { is_expected.to eq(false) }
-      end
-
-      describe '#extended_header?' do
-        subject { super().extended_header? }
-        it { is_expected.to eq(true) }
-      end
-
-      describe '#experimental?' do
-        subject { super().experimental? }
-        it { is_expected.to eq(false) }
-      end
-
-      describe '#footer_present?' do
-        subject { super().footer_present? }
-        it { is_expected.to eq(false) }
-      end
-    end
-    context "when flags bite is 0b00100000" do
-      let(:header_data) { "ID3\03\00#{0b00100000.chr}" }
-
-      describe '#unsynchronisation?' do
-        subject { super().unsynchronisation? }
-        it { is_expected.to eq(false) }
-      end
-
-      describe '#extended_header?' do
-        subject { super().extended_header? }
-        it { is_expected.to eq(false) }
-      end
-
-      describe '#experimental?' do
-        subject { super().experimental? }
-        it { is_expected.to eq(true) }
-      end
-
-      describe '#footer_present?' do
-        subject { super().footer_present? }
-        it { is_expected.to eq(false) }
-      end
-    end
-    context "when flags bite is 0b00010000" do
-      let(:header_data) { "ID3\03\00#{0b00010000.chr}" }
-
-      describe '#unsynchronisation?' do
-        subject { super().unsynchronisation? }
-        it { is_expected.to eq(false) }
-      end
-
-      describe '#extended_header?' do
-        subject { super().extended_header? }
-        it { is_expected.to eq(false) }
-      end
-
-      describe '#experimental?' do
-        subject { super().experimental? }
-        it { is_expected.to eq(false) }
-      end
-
-      describe '#footer_present?' do
-        subject { super().footer_present? }
-        it { is_expected.to eq(true) }
-      end
-    end
-  end
-
-  describe "#tag_size" do
-    let(:header_data) { "ID3abc\x00\x00\x01\x7F" }
-
-    describe '#tag_size' do
-      subject { super().tag_size }
-      it { is_expected.to eq(255) }
-    end
-  end
-
-  describe "#inspect" do
-    let(:header_data) { "ID3\u0003\u0000\u0000\u0000\u0000\u0000\u0000" }
-
-    describe '#inspect' do
-      subject { super().inspect }
-      it { is_expected.to eq "<ID3Tag::ID3v2TagHeader version:2.3.0 size:0 unsync:false ext.header:false experimental:false footer:false>" }
-    end
-  end
-end

data/spec/lib/id3tag/id3tag_spec.rb

@@ -1,17 +0,0 @@
-require "spec_helper"
-
-describe ID3Tag do
-  let(:file) { mp3_fixture('id3v2.mp3') }
-  describe "#read" do
-    it "reads file tag" do
-      expect(ID3Tag.read(file)).to be_instance_of(ID3Tag::Tag)
-    end
-
-    it "accepts block" do
-      expect do |b|
-        ID3Tag.read(file, &b)
-      end.to yield_control
-    end
-  end
-end
-

data/spec/lib/id3tag/io_util_spec.rb

@@ -1,30 +0,0 @@
-require "spec_helper"
-
-describe ID3Tag::IOUtil do
-
-  describe "#read_until_terminator" do
-    subject { ID3Tag::IOUtil.read_until_terminator(io, group_size) }
-    context "when reading IO and looking for UTF-8 terminator - 1 null byte" do
-      let(:group_size) { 1 }
-      context "when only 1 null byte present" do
-        let(:io) { StringIO.new("abcd\x00ef") }
-        it { is_expected.to eq("abcd") }
-      end
-      context "when no null bytes are present" do
-        let(:io) { StringIO.new("abcdef") }
-        it { is_expected.to eq("abcdef") }
-      end
-    end
-    context "when reading IO and looking for UTF-16 terminator - 2 null bytes" do
-      let(:group_size) { 2 }
-      context "when only 1 null byte present" do
-        let(:io) { StringIO.new("a\x00b\x00\x00\x00c\x00") }
-        it "should return content until terminator and leave cursor just right after" do
-          expect(subject).to eq("a\x00b\x00")
-          expect(io.read).to eq("c\x00")
-        end
-      end
-    end
-  end
-
-end

data/spec/lib/id3tag/number_util_spec.rb

@@ -1,32 +0,0 @@
-require "spec_helper"
-describe ID3Tag::NumberUtil do
-  describe "#convert_string_to_32bit_integer" do
-    context "when string with 4 bytes given" do
-      it "should return integer" do
-        expect(described_class.convert_string_to_32bit_integer("abcd")).to eq(1633837924)
-      end
-    end
-
-    context "when string with less than 4 bytes given" do
-      it "should raise Argument error" do
-        expect do
-          described_class.convert_string_to_32bit_integer("ab")
-        end.to raise_error(ArgumentError)
-      end
-    end
-
-    context "when non-string argument is given" do
-      it "should raise Argument error" do
-        expect do
-          described_class.convert_string_to_32bit_integer(Object.new)
-        end.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  describe "#convert_32bit_integer_to_string" do
-    it "should return 4 byte string" do
-      expect(described_class.convert_32bit_integer_to_string(1633837924)).to eq("abcd")
-    end
-  end
-end

data/spec/lib/id3tag/string_util_spec.rb

@@ -1,81 +0,0 @@
-require "spec_helper"
-
-describe ID3Tag::StringUtil do
-  describe "#blank?" do
-    subject { described_class.blank?(test_string) }
-    context "when test string is like ''" do
-      let(:test_string) { "" }
-      it { is_expected.to eq(true) }
-    end
-
-    context "when test string is like '   '" do
-      let(:test_string) { "    " }
-      it { is_expected.to eq(true) }
-    end
-
-    context "when test string is like 'foo'" do
-      let(:test_string) { "foo" }
-      it { is_expected.to eq(false) }
-    end
-  end
-
-  describe "do_unsynchronization" do
-    let(:input) { }
-    subject { described_class.do_unsynchronization(input) }
-
-    context "when a false synchronization is present" do
-      let(:input) { "\xFF\xEE" }
-      it { is_expected.to eq("\xFF\x00\xEE") }
-    end
-    context "when a false synchronization is not present" do
-      let(:input) { "\xEE\xEE" }
-      it { is_expected.to eq("\xEE\xEE") }
-    end
-  end
-
-  describe "undo_unsynchronization" do
-    let(:input) { }
-    subject { described_class.undo_unsynchronization(input) }
-
-    context "when unsynchronization in present" do
-      let(:input) { "\xFF\x00\xEE\xEE" }
-      it { is_expected.to eq("\xFF\xEE\xEE") }
-    end
-    context "when unsynchronization in not present" do
-      let(:input) { "\xEE\xEE" }
-      it { is_expected.to eq("\xEE\xEE") }
-    end
-  end
-
-  describe "cut_at_null_byte" do
-    let(:input) { }
-    subject { described_class.cut_at_null_byte(input) }
-
-    context 'when content is empty' do
-      let(:input) { '' }
-      it { is_expected.to eq('') }
-    end
-
-    context 'when content is present' do
-      let(:input) { "a\u0000b" }
-      it { is_expected.to eq('a') }
-    end
-  end
-
-  describe "split_by_null_byte" do
-    let(:input) { }
-    subject { described_class.split_by_null_byte(input) }
-    context "when content have only 1 null byte" do
-      let(:input) { "a\u0000b" }
-      it { is_expected.to eq(["a", "b"]) }
-    end
-    context "when content have multiple null bytes" do
-      let(:input) { "a\u0000\u0000b" }
-      it { is_expected.to eq(["a", "\u0000b"]) }
-    end
-    context "when content have multiple null bytes" do
-      let(:input) { "abc" }
-      it { is_expected.to eq(["abc", ""]) }
-    end
-  end
-end

data/spec/lib/id3tag/synchsafe_integer_spec.rb

@@ -1,14 +0,0 @@
-require "spec_helper"
-describe ID3Tag::SynchsafeInteger do
-  it "encodes regular integers" do
-    expect(described_class.encode(255)).to eq(383)
-    expect(described_class.encode(5)).to eq(5)
-    expect(described_class.encode(128)).to eq(256)
-  end
-
-  it "decodes synchsafe integers" do
-    expect(described_class.decode(383)).to eq(255)
-    expect(described_class.decode(5)).to eq(5)
-    expect(described_class.decode(256)).to eq(128)
-  end
-end

data/spec/lib/id3tag/tag_spec.rb

@@ -1,352 +0,0 @@
-require "spec_helper"
-
-describe ID3Tag::Tag do
-  describe "class method #read"
-
-  describe "#get_frame" do
-    subject { described_class.read(nil) }
-    context "when more that one frame by that ID exists" do
-      before :each do
-        allow(subject).to receive(:get_frames) { [:frame, :frame] }
-      end
-      it "should raise MultipleFrameError" do
-        expect { subject.get_frame(:some_unique_frame) }.to raise_error(ID3Tag::Tag::MultipleFrameError)
-      end
-    end
-
-    context "when only one frame by that ID exists" do
-      before :each do
-        allow(subject).to receive(:get_frames) { [:frame] }
-      end
-      it "should return the frame" do
-        expect(subject.get_frame(:some_unique_frame)).to eq(:frame)
-      end
-    end
-  end
-
-  describe "#get_frames" do
-    subject { described_class.read(nil) }
-    let(:a1) { ID3Tag::Frames::V1::TextFrame.new(:A, 'a1') }
-    let(:a2) { ID3Tag::Frames::V1::TextFrame.new(:A, 'a2') }
-    let(:b) { ID3Tag::Frames::V1::TextFrame.new(:B, 'b') }
-    before :each do
-      allow(subject).to receive(:frames) { [a1, a2, b] }
-    end
-    it "returns frames with specific IDs" do
-      expect(subject.get_frames(:A)).to eq([a1, a2])
-    end
-  end
-
-  describe "#frames" do
-    subject { described_class.read(nil) }
-    before do
-      allow(subject).to receive(:v1_frames) { [:v1_frame1, :v1_frame2] }
-      allow(subject).to receive(:v2_frames) { [:v2_frame1, :v2_frame2] }
-    end
-    it "returns v2 frames and v1 frames" do
-      expect(subject.frames).to eq([:v2_frame1, :v2_frame2, :v1_frame1, :v1_frame2])
-    end
-  end
-
-  describe "#frame_ids" do
-    subject { described_class.read(nil) }
-    let(:frame_1) { ID3Tag::Frames::V1::TextFrame.new(:AA, 'a1') }
-    let(:frame_2) { ID3Tag::Frames::V1::TextFrame.new(:BB, 'a2') }
-    before do
-      allow(subject).to receive(:frames) { [frame_1, frame_2] }
-    end
-    it "returns frames ids" do
-      expect(subject.frame_ids).to eq([:AA, :BB])
-    end
-  end
-
-  describe "#v1_frames" do
-    context "when tag reading initialized with v1 tag only" do
-      subject { described_class.read(nil, :v1) }
-      context "when file has v1 tag" do
-        before do
-          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v1_tag_present?) { true }
-          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v1_tag_body) { '' }
-          allow_any_instance_of(ID3Tag::ID3V1FrameParser).to receive(:frames) { [:v1_frame] }
-        end
-        it "reads v1 tags" do
-          expect(subject.v1_frames).to eq([:v1_frame])
-        end
-      end
-
-      context "when file does not have v1 tag" do
-        before do
-          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v1_tag_present?) { false }
-          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v1_tag_body) { '' }
-        end
-        it "returns empty array" do
-          expect(subject.v1_frames).to eq([])
-        end
-      end
-    end
-
-    context "when tag reading initialized with v2 tag only" do
-      subject { described_class.read(nil, :v2) }
-      context "when file has v1 tag" do
-        before do
-          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v1_tag_present?) { true }
-          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v1_tag_body) { '' }
-        end
-        it "reads v1 tags" do
-          expect(subject.v1_frames).to eq([])
-        end
-      end
-    end
-
-    context "when tag reading initialized with all versions flag" do
-      subject { described_class.read(nil, :all) }
-      context "when file has v1 tag" do
-        before do
-          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v1_tag_present?) { true }
-          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v1_tag_body) { '' }
-          allow_any_instance_of(ID3Tag::ID3V1FrameParser).to receive(:frames) { [:v1_frame] }
-        end
-        it "reads v1 tags" do
-          expect(subject.v1_frames).to eq([:v1_frame])
-        end
-      end
-    end
-  end
-
-  describe "#v2_frames" do
-    before do
-      allow_any_instance_of(ID3Tag::AudioFile).to receive(:v2_tag_major_version_number) { 3 }
-    end
-    context "when tag reading initialized with v2 tag only" do
-      subject { described_class.read(nil, :v2) }
-      context "when file has v2 tag" do
-        before do
-          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v2_tag_present?) { true }
-          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v2_tag_body) { '' }
-          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v2_tag_size) { 120 }
-          allow_any_instance_of(ID3Tag::ID3V2FrameParser).to receive(:frames) { [:v2_frame] }
-        end
-        it "reads v2 tags" do
-          expect(subject.v2_frames).to eq([:v2_frame])
-        end
-      end
-
-      context "when file does not have v2 tag" do
-        before do
-          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v2_tag_present?) { false }
-          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v2_tag_body) { '' }
-        end
-        it "returns empty array" do
-          expect(subject.v2_frames).to eq([])
-        end
-      end
-    end
-
-    context "when tag reading initialized with v1 tag only" do
-      subject { described_class.read(nil, :v1) }
-      context "when file has v2 tag" do
-        before do
-          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v2_tag_present?) { true }
-          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v2_tag_body) { '' }
-        end
-        it "returns empty array" do
-          expect(subject.v2_frames).to eq([])
-        end
-      end
-    end
-
-    context "when tag reading initialized with all versions flag" do
-      subject { described_class.read(nil, :all) }
-      context "when file has v2 tag" do
-        before do
-          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v2_tag_present?) { true }
-          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v2_tag_body) { '' }
-          allow_any_instance_of(ID3Tag::AudioFile).to receive(:v2_tag_size) { 120 }
-          allow_any_instance_of(ID3Tag::ID3V2FrameParser).to receive(:frames) { [:v2_frame] }
-        end
-        it "reads v2 tags" do
-          expect(subject.v2_frames).to eq([:v2_frame])
-        end
-      end
-    end
-  end
-
-  describe "Tests with real-world tags" do
-    let(:audio_file) { double("Fake Audio file") }
-
-    subject do
-      described_class.new(nil, scope_version).tap do |obj|
-        allow(obj).to receive(:audio_file) { audio_file }
-      end
-    end
-
-    before do
-      allow(audio_file).to receive_messages({
-                          :v1_tag_present?             => v1_tag_present_flag,
-                          :v2_tag_present?             => v2_tag_present_flag,
-                          :v1_tag_body                 => v1_tag_body,
-                          :v1_tag_size                 => v1_tag_body.to_s.size,
-                          :v2_tag_body                 => v2_tag_body,
-                          :v2_tag_size                 => v2_tag_body.to_s.size,
-                          :v2_tag_major_version_number => v2_tag_major_version_number
-                      })
-    end
-
-    context "signals_1.mp3.v2_3_tag_body" do
-      let(:v1_tag_present_flag) { true }
-      let(:v2_tag_present_flag) { true }
-      let(:v1_tag_body) {  }
-      let(:v2_tag_body) { mp3_fixture("signals_1.mp3.v2_3_tag_body").read }
-      let(:v2_tag_major_version_number) { 3 }
-
-      context "Reading only v2" do
-        let(:scope_version) { :v2 }
-
-        describe '#artist' do
-          subject { super().artist }
-          it { is_expected.to eq("Sabled Sun") }
-        end
-
-        describe '#title' do
-          subject { super().title }
-          it { is_expected.to eq("Sabled Sun - Signals I") }
-        end
-
-        describe '#album' do
-          subject { super().album }
-          it { is_expected.to eq("Signals I") }
-        end
-
-        describe '#year' do
-          subject { super().year }
-          it { is_expected.to eq("2013") }
-        end
-
-        describe '#track_nr' do
-          subject { super().track_nr }
-          it { is_expected.to eq "1" }
-        end
-
-        describe '#genre' do
-          subject { super().genre }
-          it { is_expected.to eq "Jazz" }
-        end
-
-        describe '#comments' do
-          subject { super().comments }
-          it { is_expected.to eq("Visit http://cryochamber.bandcamp.com") }
-        end
-        it "should return eng comment" do
-          expect(subject.comments(:eng)).to eq("Visit http://cryochamber.bandcamp.com")
-        end
-        it "should read private frames" do
-          expect(subject.get_frames(:PRIV).find { |f| f.owner_identifier.force_encoding(Encoding::UTF_8) == "WM/MediaClassPrimaryID" }).to be_kind_of(ID3Tag::Frames::V2::PrivateFrame)
-        end
-      end
-    end
-
-    context "pov_20131018-2100a.mp3" do
-      let(:v1_tag_present_flag) { true }
-      let(:v2_tag_present_flag) { true }
-      let(:v1_tag_body) { mp3_fixture("pov_20131018-2100a.mp3.v1_tag_body").read }
-      let(:v2_tag_body) { mp3_fixture("pov_20131018-2100a.mp3.v2_3_tag_body").read }
-      let(:v2_tag_major_version_number) { 3 }
-
-      context "Reading only v1" do
-        let(:scope_version) { :v1 }
-
-        describe '#artist' do
-          subject { super().artist }
-          it { is_expected.to eq("") }
-        end
-
-        describe '#title' do
-          subject { super().title }
-          it { is_expected.to eq("pov_20131018-2100a.mp3") }
-        end
-
-        describe '#album' do
-          subject { super().album }
-          it { is_expected.to eq("") }
-        end
-
-        describe '#year' do
-          subject { super().year }
-          it { is_expected.to eq("") }
-        end
-
-        describe '#track_nr' do
-          subject { super().track_nr }
-          it { is_expected.to be_nil }
-        end
-
-        describe '#genre' do
-          subject { super().genre }
-          it { is_expected.to eq("Blues") }
-        end
-
-        describe '#comments' do
-          subject { super().comments }
-          it { is_expected.to be_nil }
-        end
-
-        describe '#frame_ids' do
-          subject { super().frame_ids }
-          it { is_expected.to eq [:title, :artist, :album, :year, :comments, :genre] }
-        end
-      end
-      context "Reading only v2" do
-        let(:scope_version) { :v2 }
-
-        describe '#artist' do
-          subject { super().artist }
-          it { is_expected.to eq("BBC Radio 4") }
-        end
-
-        describe '#title' do
-          subject { super().title }
-          it { is_expected.to eq("PoV: Lisa Jardine: Machine Intelligence: 18 Oct 13") }
-        end
-
-        describe '#album' do
-          subject { super().album }
-          it { is_expected.to eq("A Point of View") }
-        end
-
-        describe '#year' do
-          subject { super().year }
-          it { is_expected.to eq("2013") }
-        end
-
-        describe '#track_nr' do
-          subject { super().track_nr }
-          it { is_expected.to be_nil }
-        end
-        it "should return nil for genre as this tag have incorect genre frame" do
-          expect(subject.genre).to eq("")
-        end
-
-        describe '#comments' do
-          subject { super().comments }
-          it { is_expected.to eq("Lisa Jardine compares the contributions of Ada Lovelace and Alan Turing a century later to computer science and contrasts their views on the potential of and limits to machine intelligence. \r\nProducer: Sheila Cook") }
-        end
-        it "should return eng comment" do
-          expect(subject.comments(:eng)).to eq("Lisa Jardine compares the contributions of Ada Lovelace and Alan Turing a century later to computer science and contrasts their views on the potential of and limits to machine intelligence. \r\nProducer: Sheila Cook")
-        end
-        it "should return blank string for latvian comments" do
-          expect(subject.comments(:lav)).to be_nil
-        end
-
-        describe '#frame_ids' do
-          subject { super().frame_ids }
-          it { is_expected.to eq [:TALB, :TPE1, :COMM, :USLT, :TCON, :TIT2, :TYER, :TCOP, :APIC] }
-        end
-        it "should have comments frame with short desc and language code" do
-          expect(subject.get_frames(:COMM).size).to eq(1)
-          expect(subject.get_frame(:COMM).language).to eq("eng")
-          expect(subject.get_frame(:COMM).description).to eq("")
-        end
-      end
-    end
-  end
-end