mp3info 0.6.18 → 0.8.5

data/mp3info.gemspec

@@ -1,17 +0,0 @@
-# encoding: UTF-8
-
-Gem::Specification.new do |s|
-  s.name        = 'mp3info'
-  s.version     = '0.6.18'
-  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

@@ -1,86 +0,0 @@
-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

@@ -1,572 +0,0 @@
-#!/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