mp3info 0.6.17

data/mp3info.gemspec

@@ -0,0 +1,17 @@
+# encoding: UTF-8
+
+Gem::Specification.new do |s|
+  s.name        = 'mp3info'
+  s.version     = '0.6.17'
+  s.summary     = %q{Read low-level informations and manipulate tags on mp3 files.}
+  s.homepage    = "http://github.com/toy/#{s.name}"
+  s.authors     = ['Guillaume Pierronnet', 'Ivan Kuchin']
+  s.license     = 'ruby'
+
+  s.rubyforge_project = s.name
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = %w[lib]
+end

data/test/fixtures.yml

@@ -0,0 +1,86 @@
+empty_mp3: !binary |
+  eJz7/3tCCgP/BwaGTAYGBg4GBl4FBgZGIFoC5AKZJg0MDCw+jr6uxnqW5qEj
+  EAy43///npSyrx9/BA2Y4wYDGBQx9H80hnCD0Rga7GA0hkYBAQAA8NuaUA==
+2_2_tagged: !binary |
+  eNrtlrlOw0AQhn8QZ4E4CioK90jO2k58dGxs5xBxYiWbgiqKiAUWSmLZBFEi
+  XgDEM/AcPBN9imDHOBEIEB1H9tMW/8zO7szqb7ZqKcuI2T1gTAbWUR1chkMw
+  VwL2UQ69fiTQi67QGgVe2PdPkz1aAzZB/VBwutdgzWNgDVJO0uJjFFhNNNiJ
+  naRlQlQwswFsoeIHQmUY5JrdAGbDAXbgDc58Nhq4ZeqCAMyuA3tIUl4kXGki
+  EWVRUtPq86y63mg6EEiKlQnysZBmmdJ8y6ZToduKNK1R84oxE2m326xby3GL
+  eHe3LL0Kw5h3I6SgFaj6pr38nRE/EekcR9kcXtQxLavYqVoRJO1QpqZVMqgt
+  23aeqKqu5PXkRfNhdEUr6LIGDofD4XD+KpPxfQ/bz4AfBxvxX0IAluL1GIex
+  zN8AKzXq2IpoaO0F5MffPhk/9J7uvjaovcj8Cocm3CHuEHeIO/RveQFv4P/e
+vbr: !binary |
+  eNrt0F1k1XEYB/DnWHI0x0kiTTIzZqyRTS8jlV4kHSMdLdJFjuaQKYmMlCUm
+  siSbSBcZqbGNGYnpIimzRBKJLpKYmJFIU6f/uegyZ1f/yOfr4fc8PHwev8rS
+  jVLUSE+5rzd58hENuVg1PB91K7P1ufyatevWb9jY1NzS2ta+uWPLtq4dO/fs
+  P3Cw0H34yNFjx0+cLPWWT/edPXf+Qv/FS1euDl67PnTz1sjtO3fvjd5/MDY+
+  OTX96PHMk6fPXsy+fPX6zdt37z98/PR5/svC4tdv33/8TLyuQ7sL+zrat29t
+  rJuonrHpV0TnmebsrkJk5qp3DGTGn8f/nsrS6lLkFyPKyZCNyDVGZJIaTcak
+  7bwcseLPRxX/lpoLxWLVaarhFGtlmc7elJxTKTmDKTkPU3LmUnIWUnIqQxwO
+  h8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8Ph
+  cDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgc
+  DofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD
+  4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4
+  HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6H
+  w+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+Fw
+  OBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwO
+  h8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8Ph
+  cDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgc
+  DofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD
+  4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4
+  HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6H
+  w+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+Fw
+  OBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwO
+  h8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8Ph
+  cDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgc
+  DofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD
+  4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4
+  HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6H
+  w+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+Fw
+  OBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwO
+  h8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8Ph
+  cDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgc
+  DofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD
+  4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4
+  HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6H
+  w+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+Fw
+  OBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwO
+  h8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8Ph
+  cDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgc
+  DofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD
+  4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4
+  HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6H
+  w+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+Fw
+  OBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwO
+  h8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8Ph
+  cDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgc
+  DofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD
+  4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4
+  HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6H
+  w+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+Fw
+  OBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwO
+  h8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8Ph
+  cDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgc
+  DofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD
+  4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4
+  HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6H
+  w+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+Fw
+  OBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwO
+  h8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8Ph
+  cDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgc
+  DofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD4XA4HA6Hw+FwOBwOh8PhcDgcDofD
+  4XA4HM4/dJYRDidN5zc6LQlL
+audio_content_fixture: !binary |
+  SUQzAwAAAAABDFRBTEIAAAAnAAAB//5SAG8AZAByAGkAZwBvACAAeQAgAEcA
+  YQBiAHIAaQBlAGwAYQBUUkNLAAAABQAAAf/+MQBUSVQyAAAAEQAAAf/+VABh
+  AG0AYQBjAHUAbgBUUEUxAAAAJwAAAf/+UgBvAGQAcgBpAGcAbwAgAHkAIABH
+  AGEAYgByAGkAZQBsAGEA//uQZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+  AAAAAAAAWGluZwAAAA8AAB7IAFw7mAADBQgKDQ8SFBcZHB4gIyUoKi4wMzU4
+  Oj1AQkVIS01QUlVYW11gYmRoam1vcnR3en1/gYSGiYuOkZSWmZueoKKmqKut
+  sLO2uLu9wMLFyMrNz9LU2Nrd3+Pl5+rs7/H19/r8//8AAABOTEFNRTMuOTAu
+  A74AAAAAAAAAADSAJAV8TQAAAABcO5gcQelNAAAAAAAAAAAAAAAAAAAAAAAA
+  AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+  AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+  AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+  AAAAAAAAAAAAAAAAAAAAAAA=

data/test/test_ruby-mp3info.rb

@@ -0,0 +1,572 @@
+#!/usr/bin/env ruby1.9
+# coding:utf-8
+
+$:.unshift("lib/")
+
+require "test/unit"
+require "mp3info"
+require "fileutils"
+require "tempfile"
+require "zlib"
+require "yaml"
+
+system("which id3v2 > /dev/null") || raise("id3v2 not found")
+
+class Mp3InfoTest < Test::Unit::TestCase
+
+  TEMP_FILE = File.join(File.dirname(__FILE__), "test_mp3info.mp3")
+
+  DUMMY_TAG2 = {
+    "COMM" => "comments",
+    #"TCON" => "genre_s"
+    "TIT2" => "title",
+    "TPE1" => "artist",
+    "TALB" => "album",
+    "TYER" => "year",
+    "TRCK" => "tracknum"
+  }
+
+  DUMMY_TAG1 = {
+    "title"    => "toto",
+    "artist"   => "artist 123",
+    "album"    => "ALBUMM",
+    "year"     => 1934,
+    "tracknum" => 14,
+    "comments" => "comment me",
+    "genre" => 233
+  }
+
+  FIXTURES = YAML::load_file( File.join(File.dirname(__FILE__), "fixtures.yml") )
+
+  def setup
+    # Command to create a gzip'ed dummy MP3
+    # $ dd if=/dev/zero bs=1024 count=15 | \
+    #   lame --quiet --preset cbr 128 -r -s 44.1 --bitwidth 16 - - | \
+    #   ruby -rbase64 -rzlib -ryaml -e 'print(Zlib::Deflate.deflate($stdin.read)'
+    # vbr:
+    # $ dd if=/dev/zero of=#{tempfile.path} bs=1024 count=30000 |
+    #     system("lame -h -v -b 112 -r -s 44.1 --bitwidth 16 - /tmp/vbr.mp3
+    @valid_mp3, @valid_mp3_2_2, @vbr_mp3 = %w{empty_mp3 2_2_tagged vbr}.collect do |fixture_key|
+      Zlib::Inflate.inflate(FIXTURES[fixture_key])
+    end
+
+    @tag = {
+      "title" => "title",
+      "artist" => "artist",
+      "album" => "album",
+      "year" => 1921,
+      "comments" => "comments",
+      "genre" => 0,
+      "genre_s" => "Blues",
+      "tracknum" => 36
+    }
+    File.open(TEMP_FILE, "w") { |f| f.write(@valid_mp3) }
+  end
+
+  def teardown
+    FileUtils.rm_f(TEMP_FILE)
+  end
+
+  def test_to_s
+    Mp3Info.open(TEMP_FILE) { |info| assert(info.to_s.is_a?(String)) }
+  end
+
+  def test_not_an_mp3
+    File.open(TEMP_FILE, "w") do |f|
+      str = "0"*1024*1024
+      f.write(str)
+    end
+    assert_raises(Mp3InfoError) do
+      mp3 = Mp3Info.new(TEMP_FILE)
+    end
+  end
+
+  def test_is_an_mp3
+    assert_nothing_raised do
+      Mp3Info.new(TEMP_FILE).close
+    end
+  end
+
+  def test_detected_info
+    Mp3Info.open(TEMP_FILE) do |mp3|
+      assert_mp3_info_are_ok(mp3)
+    end
+  end
+
+  def test_vbr_mp3_length
+    File.open(TEMP_FILE, "w") { |f| f.write(@vbr_mp3) }
+
+    Mp3Info.open(TEMP_FILE) do |info|
+      assert(info.vbr)
+      assert_in_delta(174.210612, info.length, 0.000001)
+    end
+  end
+
+  def test_removetag1
+    Mp3Info.open(TEMP_FILE) { |info| info.tag1 = @tag }
+    assert(Mp3Info.hastag1?(TEMP_FILE))
+    Mp3Info.removetag1(TEMP_FILE)
+    assert(! Mp3Info.hastag1?(TEMP_FILE))
+  end
+
+  def test_writetag1
+    Mp3Info.open(TEMP_FILE) { |info| info.tag1 = @tag }
+    Mp3Info.open(TEMP_FILE) { |info| assert_equal(info.tag1, @tag) }
+  end
+
+  def test_valid_tag1_1
+    tag = [ "title", "artist", "album", "1921", "comments", 36, 0].pack('A30A30A30A4a29CC')
+    valid_tag = {
+      "title" => "title",
+      "artist" => "artist",
+      "album" => "album",
+      "year" => 1921,
+      "comments" => "comments",
+      "genre" => "Blues",
+      #"version" => "1",
+      "tracknum" => 36
+    }
+    id3_test(tag, valid_tag)
+  end
+
+  def test_valid_tag1_0
+    tag = [ "title", "artist", "album", "1921", "comments", 0].pack('A30A30A30A4A30C')
+    valid_tag = {
+      "title" => "title",
+      "artist" => "artist",
+      "album" => "album",
+      "year" => 1921,
+      "comments" => "comments",
+      "genre" => "Blues",
+      #"version" => "0"
+    }
+    id3_test(tag, valid_tag)
+  end
+
+  def id3_test(tag_str, valid_tag)
+    tag = "TAG" + tag_str
+    File.open(TEMP_FILE, "w") do |f|
+      f.write(@valid_mp3)
+      f.write(tag)
+    end
+    assert(Mp3Info.hastag1?(TEMP_FILE))
+    #info = Mp3Info.new(TEMP_FILE)
+    #FIXME validate this test
+    #assert_equal(info.tag1, valid_tag)
+  end
+
+  def test_removetag2
+    w = write_tag2_to_temp_file({"TIT2" => "sdfqdsf"})
+
+    assert( Mp3Info.hastag2?(TEMP_FILE) )
+    Mp3Info.removetag2(TEMP_FILE)
+    assert( ! Mp3Info.hastag2?(TEMP_FILE) )
+  end
+
+  def test_hastags
+    Mp3Info.open(TEMP_FILE) do |info|
+      info.tag1 = @tag
+    end
+    assert(Mp3Info.hastag1?(TEMP_FILE))
+
+    written_tag = write_tag2_to_temp_file(DUMMY_TAG2)
+    assert(Mp3Info.hastag2?(TEMP_FILE))
+  end
+
+  def test_universal_tag
+    2.times do
+      tag = {"title" => "title"}
+      Mp3Info.open(TEMP_FILE) do |mp3|
+        tag.each { |k,v| mp3.tag[k] = v }
+      end
+      w = Mp3Info.open(TEMP_FILE) { |m| m.tag }
+      assert_equal(tag, w)
+    end
+  end
+
+  def test_id3v2_universal_tag
+    tag = {}
+    %w{comments title artist album}.each { |k| tag[k] = k }
+    tag["tracknum"] = 34
+    Mp3Info.open(TEMP_FILE) do |mp3|
+      tag.each { |k,v| mp3.tag[k] = v }
+    end
+    w = Mp3Info.open(TEMP_FILE) { |m| m.tag }
+    w.delete("genre")
+    w.delete("genre_s")
+    assert_equal(tag, w)
+#    id3v2_prog_test(tag, w)
+  end
+
+  def test_id3v2_version
+    written_tag = write_tag2_to_temp_file(DUMMY_TAG2)
+    assert_equal( "2.#{ID3v2::WRITE_VERSION}.0", written_tag.version )
+  end
+
+  def test_id3v2_methods
+    tag = { "TIT2" => "tit2", "TPE1" => "tpe1" }
+    Mp3Info.open(TEMP_FILE) do |mp3|
+      tag.each do |k, v|
+        mp3.tag2.send("#{k}=".to_sym, v)
+      end
+      assert_equal(tag, mp3.tag2)
+    end
+  end
+
+  def test_id3v2_basic
+    w = write_tag2_to_temp_file(DUMMY_TAG2)
+    assert_equal(DUMMY_TAG2, w)
+    id3v2_prog_test(DUMMY_TAG2, w)
+  end
+
+  #test the tag with the "id3v2" program
+  def id3v2_prog_test(tag, written_tag)
+    return if RUBY_PLATFORM =~ /win32/
+    return if `which id3v2`.empty?
+    start = false
+    id3v2_output = {}
+    `id3v2 -l #{TEMP_FILE}`.split(/\n/).each do |line|
+      if m = /^(.{4}) \(.+\): (.+)$/.match(line)
+        k, v = m[1, 2]
+        case k
+        when "COMM"
+          v.sub!(/\(\)\[.{3}\]: (.+)/, '\1')
+        end
+        id3v2_output[k] = v
+      end
+    end
+
+    assert_equal( id3v2_output, written_tag, "id3v2 program output doesn't match")
+  end
+
+  def test_id3v2_trash
+  end
+
+  def test_id3v2_complex
+    tag = {}
+    #ID3v2::TAGS.keys.each do |k|
+    ["PRIV", "APIC"].each do |k|
+      tag[k] = random_string(50)
+    end
+
+    got_tag = write_tag2_to_temp_file(tag)
+    assert_equal(tag, got_tag)
+  end
+
+  def test_id3v2_bigtag
+    tag = {"APIC" => random_string(1024) }
+    assert_equal(tag, write_tag2_to_temp_file(tag))
+  end
+
+  def test_infinite_loop_on_seek_to_v2_end
+
+  end
+
+  def test_leading_char_gets_chopped
+    tag2 = DUMMY_TAG2.dup
+    tag2["WOAR"] = "http://foo.bar"
+    w = write_tag2_to_temp_file(tag2)
+    assert_equal("http://foo.bar", w["WOAR"])
+
+    system(%(id3v2 --WOAR "http://foo.bar" "#{TEMP_FILE}"))
+
+    Mp3Info.open(TEMP_FILE) do |mp3|
+      assert_equal "http://foo.bar", mp3.tag2["WOAR"]
+    end
+  end
+
+  def test_reading2_2_tags
+    File.open(TEMP_FILE, "w") { |f| f.write(@valid_mp3_2_2) }
+
+    Mp3Info.open(TEMP_FILE) do |mp3|
+      assert_equal "2.2.0", mp3.tag2.version
+      expected_tag = {
+        "TCO" => "Hip Hop/Rap",
+        "TP1" => "Grems Aka Supermicro",
+        "TT2" => "Intro",
+        "TAL" => "Air Max",
+        "TEN" => "iTunes v7.0.2.16",
+        "TYE" => "2006",
+        "TRK" => "1/17",
+        "TPA" => "1/1" }
+      tag = mp3.tag2.dup
+      assert_equal 4, tag["COM"].size
+      tag.delete("COM")
+      assert_equal expected_tag, tag
+
+      expected_tag = {
+        "genre_s"       => "Hip Hop/Rap",
+        "title"         => "Intro",
+        #"comments"      => "\000engiTunPGAP\0000\000\000",
+        "comments"      => "0",
+        "year"          => 2006,
+        "album"         => "Air Max",
+        "artist"        => "Grems Aka Supermicro",
+        "tracknum"      => 1 }
+      # test universal tag
+      assert_equal expected_tag, mp3.tag
+    end
+  end
+
+  def test_writing_universal_tag_from_2_2_tags
+    File.open(TEMP_FILE, "w") { |f| f.write(@valid_mp3_2_2) }
+    Mp3Info.open(TEMP_FILE) do |mp3|
+      mp3.tag.artist = "toto"
+      mp3.tag.comments = "comments"
+      mp3.flush
+      expected_tag = {
+        "artist" => "toto",
+        "genre_s" => "Hip Hop/Rap",
+        "title" => "Intro",
+        "comments" => "comments",
+        "year" => 2006,
+        "album" => "Air Max",
+        "tracknum" => 1}
+
+      assert_equal expected_tag, mp3.tag
+    end
+  end
+
+  def test_remove_tag
+    Mp3Info.open(TEMP_FILE) do |mp3|
+      tag = mp3.tag
+      tag.title = "title"
+      tag.artist = "artist"
+      mp3.close
+      mp3.reload
+      assert !mp3.tag1.empty?, "tag is empty"
+      mp3.removetag1
+      mp3.flush
+      assert mp3.tag1.empty?, "tag is not empty"
+    end
+  end
+
+  def test_good_parsing_of_a_pathname
+    fn = "Freak On `(Stone´s Club Mix).mp3"
+    FileUtils.cp(TEMP_FILE, fn)
+    begin
+      Mp3Info.open(fn) do |mp3|
+        mp3.tag.title = fn
+        mp3.flush
+        if RUBY_VERSION < "1.9.0"
+          assert_equal fn, mp3.tag.title
+        else
+          assert_equal fn, mp3.tag.title.force_encoding("utf-8")
+        end
+      end
+    ensure
+      File.delete(fn)
+    end
+  end
+
+  def test_validity_of_id3v2_options
+    info = Mp3Info.new(TEMP_FILE)
+    expected_hash = { :lang => "ENG", :encoding => "iso-8859-1" }
+    assert_equal( expected_hash, info.tag2.options)
+
+    assert_raises(ArgumentError) do
+      Mp3Info.new(TEMP_FILE, :encoding => "bad encoding")
+    end
+  end
+
+  def test_encoding_read
+    Mp3Info.open(TEMP_FILE) do |mp3|
+      mp3.tag2['TEST'] = "all\xe9"
+    end
+
+    Mp3Info.open(TEMP_FILE, :encoding => "utf-8") do |mp3|
+      assert_equal "allé", mp3.tag2['TEST']
+    end
+
+    Mp3Info.open(TEMP_FILE, :encoding => "iso-8859-1") do |mp3|
+      if RUBY_VERSION < "1.9.0"
+        assert_equal "all\xe9", mp3.tag2['TEST']
+      else
+        assert_equal "all\xe9".force_encoding("binary"), mp3.tag2['TEST']
+      end
+    end
+  end
+
+  def test_encoding_write
+    Mp3Info.open(TEMP_FILE, :encoding => 'utf-8') do |mp3|
+      mp3.tag2['TEST'] = "all\xc3\xa9"
+    end
+
+    Mp3Info.open(TEMP_FILE, :encoding => "iso-8859-1") do |mp3|
+      if RUBY_VERSION < "1.9.0"
+        assert_equal "all\xe9", mp3.tag2['TEST']
+      else
+        assert_equal "all\xe9".force_encoding("iso-8859-1"), mp3.tag2['TEST']
+      end
+    end
+  end
+
+=begin
+  def test_should_raises_exception_when_writing_badly_encoded_frames
+    assert_raises(Iconv::Failure) do
+      Mp3Info.open(TEMP_FILE, :encoding => 'utf-8') do |mp3|
+        mp3.tag2['TEST'] = "all\xc3"
+      end
+    end
+  end
+=end
+
+  def test_audio_content
+    require "digest/md5"
+
+    expected_digest = nil
+    Mp3Info.open(TEMP_FILE) do |mp3|
+      mp3.tag1.update(DUMMY_TAG1)
+      mp3.tag2.update(DUMMY_TAG2)
+      mp3.flush
+      assert mp3.hastag1?
+      assert mp3.hastag2?
+      assert mp3.tag2.io_position != 0
+      expected_digest = compute_audio_content_mp3_digest(mp3)
+    end
+
+    Mp3Info.open(TEMP_FILE) do |mp3|
+      mp3.removetag1
+      mp3.removetag2
+      mp3.flush
+      assert !mp3.hastag1?
+      assert !mp3.hastag2?
+      got_digest = compute_audio_content_mp3_digest(mp3)
+      assert_equal expected_digest, got_digest
+    end
+  end
+
+  def test_audio_content_problematic
+    File.open(TEMP_FILE, "w") { |f| f.write(FIXTURES["audio_content_fixture"]) }
+    Mp3Info.open(TEMP_FILE) do |mp3|
+      expected_pos = 150
+      audio_content_pos, audio_content_size = mp3.audio_content
+      assert_equal expected_pos, audio_content_pos
+      assert_equal File.size(TEMP_FILE) - expected_pos, audio_content_size
+    end
+  end
+
+  def test_headerless_vbr_file
+    mp3_length = 3
+    # this will generate a 15 sec mp3 file (44100hz*16bit*2channels) = 60/4 = 15
+    system("dd if=/dev/urandom bs=44100 count=#{mp3_length*4}  2>/dev/null | \
+            lame -v -m s --vbr-new --preset 128 -r -s 44.1 --bitwidth 16 - -  > #{TEMP_FILE} 2>/dev/null")
+
+    Mp3Info.open(TEMP_FILE) do |mp3|
+      assert mp3.vbr
+      assert_in_delta(mp3_length, mp3.length, 0.1)
+      assert_in_delta(128, mp3.bitrate, 8)
+    end
+  end
+
+  def test_parse_tags_disabled
+    write_tag2_to_temp_file(DUMMY_TAG2)
+    Mp3Info.open(TEMP_FILE, :parse_tags => false) do |mp3|
+      assert mp3.tag.empty?
+      assert mp3.tag1.empty?
+      assert mp3.tag2.empty?
+      mp3.tag["artist"] = "some dummy tag"
+      mp3.tag2["TIT2"] = "title 2"
+      mp3.flush
+      # tag should not be written
+      assert mp3.tag.empty?
+      assert mp3.tag1.empty?
+      assert mp3.tag2.empty?
+    end
+  end
+
+  def test_string_io
+    io = load_string_io
+    Mp3Info.open(io) do |mp3|
+      assert_mp3_info_are_ok(mp3)
+    end
+  end
+
+  def test_trying_to_rename_a_stringio_should_raise_an_error
+    io = load_string_io
+    Mp3Info.open(io) do |mp3|
+      assert_raises(Mp3InfoError) do
+        mp3.rename("whatever_filename_is_error_should_be_raised.mp3")
+      end
+    end
+  end
+
+  def test_hastag_class_methods_with_a_stringio
+    Mp3Info.open(TEMP_FILE) do |info|
+      info.tag1 = @tag
+    end
+    io = load_string_io
+    assert(Mp3Info.hastag1?(io))
+
+    written_tag = write_tag2_to_temp_file(DUMMY_TAG2)
+    io = load_string_io
+    assert(Mp3Info.hastag2?(io))
+  end
+
+  def compute_audio_content_mp3_digest(mp3)
+    pos, size = mp3.audio_content
+    data = File.open(mp3.filename) do |f|
+      f.seek(pos, IO::SEEK_SET)
+      f.read(size)
+    end
+    Digest::MD5.new.update(data).hexdigest
+  end
+
+  def write_tag2_to_temp_file(tag)
+    Mp3Info.open(TEMP_FILE) do |mp3|
+      mp3.tag2.update(tag)
+    end
+    return Mp3Info.open(TEMP_FILE) { |m| m.tag2 }
+    #system("cp -v #{TEMP_FILE} #{TEMP_FILE}.test")
+  end
+
+  def random_string(size)
+    out = ""
+    size.times { out << rand(256).chr }
+    out
+  end
+
+  def assert_mp3_info_are_ok(mp3)
+    assert_equal(1, mp3.mpeg_version)
+    assert_equal(3, mp3.layer)
+    assert_equal(false, mp3.vbr)
+    assert_equal(128, mp3.bitrate)
+    assert_equal("JStereo", mp3.channel_mode)
+    assert_equal(44100, mp3.samplerate)
+    assert_equal(0.1305625, mp3.length)
+    assert_equal({:original => true,
+                  :error_protection => false,
+                  :padding => false,
+                  :emphasis => 0,
+                  :private => true,
+                  :mode_extension => 2,
+                  :copyright => false}, mp3.header)
+  end
+
+  def load_string_io(filename = TEMP_FILE)
+    io = StringIO.new
+    data = File.read(filename)
+    io.write(data)
+    io.rewind
+    io
+  end
+
+=begin
+
+  def test_encoder
+    write_to_temp
+    info = Mp3Info.new(TEMP_FILE)
+    assert(info.encoder == "Lame 3.93")
+  end
+
+  def test_vbr
+    mp3_vbr = Base64.decode64 <<EOF
+
+EOF
+    File.open(TEMP_FILE, "w") { |f| f.write(mp3_vbr) }
+    info = Mp3Info.new(TEMP_FILE)
+    assert_equal(info.vbr, true)
+    assert_equal(info.bitrate, 128)
+  end
+=end
+end