minitar 0.9 → 0.12

data/test/test_tar_input.rb

@@ -1,9 +1,9 @@
 #!/usr/bin/env ruby
 
-require 'minitar'
-require 'minitest_helper'
-require 'base64'
-require 'zlib'
+require "minitar"
+require "minitest_helper"
+require "base64"
+require "zlib"
 
 class TestTarInput < Minitest::Test
   TEST_TGZ = Base64.decode64(<<-EOS).freeze
@@ -19,23 +19,23 @@ UTAKRsEoGAWjYBSMglEwCkbBKBgFo2AUjIJRMApGwSgYBaNgFIwCUgAAGnyo6wAoAAA=
   FILETIMES = Time.utc(2004).to_i
 
   TEST_CONTENTS = {
-    'data.tar.gz' => { :size => 210, :mode => 0o644 },
-    'file3' => { :size => 18, :mode => 0o755 }
+    "data.tar.gz" => {:size => 210, :mode => 0o644},
+    "file3" => {:size => 18, :mode => 0o755}
   }.freeze
 
   TEST_DATA_CONTENTS = {
-    'data/' => { :size => 0, :mode => 0o755 },
-    'data/__dir__/' => { :size => 0, :mode => 0o755 },
-    'data/file1' => { :size => 16, :mode => 0o644 },
-    'data/file2' => { :size => 16, :mode => 0o644 }
+    "data/" => {:size => 0, :mode => 0o755},
+    "data/__dir__/" => {:size => 0, :mode => 0o755},
+    "data/file1" => {:size => 16, :mode => 0o644},
+    "data/file2" => {:size => 16, :mode => 0o644}
   }.freeze
 
   def setup
-    FileUtils.mkdir_p('data__')
+    FileUtils.mkdir_p("data__")
   end
 
   def teardown
-    FileUtils.rm_rf('data__')
+    FileUtils.rm_rf("data__")
   end
 
   def test_open_no_block
@@ -58,7 +58,7 @@ UTAKRsEoGAWjYBSMglEwCkbBKBgFo2AUjIJRMApGwSgYBaNgFIwCUgAAGnyo6wAoAAA=
         assert_equal(TEST_CONTENTS[entry.name][:size], entry.size, entry.name)
         assert_modes_equal(TEST_CONTENTS[entry.name][:mode],
           entry.mode, entry.name)
-        assert_equal(FILETIMES, entry.mtime, 'entry.mtime')
+        assert_equal(FILETIMES, entry.mtime, "entry.mtime")
 
         if i.zero?
           data_reader = Zlib::GzipReader.new(StringIO.new(entry.read))
@@ -90,8 +90,8 @@ UTAKRsEoGAWjYBSMglEwCkbBKBgFo2AUjIJRMApGwSgYBaNgFIwCUgAAGnyo6wAoAAA=
     Minitar::Input.open(reader) do |stream|
       outer_count = 0
       stream.each_with_index do |entry, i|
-        stream.extract_entry('data__', entry)
-        name = File.join('data__', entry.name)
+        stream.extract_entry("data__", entry)
+        name = File.join("data__", entry.name)
 
         assert TEST_CONTENTS.key?(entry.name)
 
@@ -108,12 +108,12 @@ UTAKRsEoGAWjYBSMglEwCkbBKBgFo2AUjIJRMApGwSgYBaNgFIwCUgAAGnyo6wAoAAA=
 
         if i.zero?
           begin
-            ff = File.open(name, 'rb')
+            ff = File.open(name, "rb")
             data_reader = Zlib::GzipReader.new(ff)
             Minitar::Input.open(data_reader) do |is2|
               is2.each_with_index do |entry2, _j|
-                is2.extract_entry('data__', entry2)
-                name2 = File.join('data__', entry2.name)
+                is2.extract_entry("data__", entry2)
+                name2 = File.join("data__", entry2.name)
 
                 assert TEST_DATA_CONTENTS.key?(entry2.name)
 
@@ -144,18 +144,18 @@ UTAKRsEoGAWjYBSMglEwCkbBKBgFo2AUjIJRMApGwSgYBaNgFIwCUgAAGnyo6wAoAAA=
     return if Minitar.windows?
 
     IO.respond_to?(:write) &&
-      IO.write('data__/file4', '') ||
-      File.open('data__/file4', 'w') { |f| f.write '' }
+      IO.write("data__/file4", "") ||
+      File.open("data__/file4", "w") { |f| f.write "" }
 
-    File.symlink('data__/file4', 'data__/file3')
-    File.symlink('data__/file4', 'data__/data')
+    File.symlink("data__/file4", "data__/file3")
+    File.symlink("data__/file4", "data__/data")
 
-    Minitar.unpack(Zlib::GzipReader.new(StringIO.new(TEST_TGZ)), 'data__')
-    Minitar.unpack(Zlib::GzipReader.new(File.open('data__/data.tar.gz', 'rb')),
-      'data__')
+    Minitar.unpack(Zlib::GzipReader.new(StringIO.new(TEST_TGZ)), "data__")
+    Minitar.unpack(Zlib::GzipReader.new(File.open("data__/data.tar.gz", "rb")),
+      "data__")
 
-    refute File.symlink?('data__/file3')
-    refute File.symlink?('data__/data')
+    refute File.symlink?("data__/file3")
+    refute File.symlink?("data__/data")
   end
 
   RELATIVE_DIRECTORY_TGZ = Base64.decode64 <<-EOS
@@ -168,7 +168,7 @@ MDUzVDAwNDY0N2VQMGCgAygtLkksAjolEcjIzMOtDqgsLQ2/J0H+gNOjYBSMglEwyAEA2LchrwAGAAA=
     Minitar::Input.open(reader) do |stream|
       stream.each do |entry|
         assert_raises Archive::Tar::Minitar::SecureRelativePathError do
-          stream.extract_entry('data__', entry)
+          stream.extract_entry("data__", entry)
         end
       end
     end
@@ -191,7 +191,7 @@ glEwCkbBKBgFo2AUjIJRMApIAQD0DyzXACgAAA==
     reader = Zlib::GzipReader.new(StringIO.new(NON_STRICT_OCTAL_TGZ))
 
     assert_raises(ArgumentError) do
-      Minitar.unpack(reader, 'data__')
+      Minitar.unpack(reader, "data__")
     end
   end
 
@@ -214,12 +214,12 @@ UTAKRsEoGAWjYBSMglFACgAAuUHUvwAoAAA=
     assert_equal(210, header.size)
 
     reader = Zlib::GzipReader.new(StringIO.new(OCTAL_WRAPPED_BY_SPACE_TGZ))
-    Minitar.unpack(reader, 'data__', [])
+    Minitar.unpack(reader, "data__", [])
   end
 
   def test_fsync_false
     outer = 0
-    Minitar.unpack(Zlib::GzipReader.new(StringIO.new(TEST_TGZ)), 'data__', [], :fsync => false) do |_label, _path, _stats|
+    Minitar.unpack(Zlib::GzipReader.new(StringIO.new(TEST_TGZ)), "data__", [], :fsync => false) do |_label, _path, _stats|
       outer += 1
     end
     assert_equal(6, outer)

data/test/test_tar_output.rb

@@ -1,24 +1,24 @@
 #!/usr/bin/env ruby
 
-require 'minitar'
-require 'minitest_helper'
+require "minitar"
+require "minitest_helper"
 
 class TestTarOutput < Minitest::Test
-  NAMES = ['a', 'b', 'c', 'd' * 200]
+  NAMES = ["a", "b", "c", "d" * 200]
 
   def setup
-    FileUtils.mkdir_p('data__')
+    FileUtils.mkdir_p("data__")
     NAMES.each do |filename|
-      name = File.join('data__', filename)
-      File.open(name, 'wb') { |f|
+      name = File.join("data__", filename)
+      File.open(name, "wb") { |f|
         f.puts "#{name}: 123456789012345678901234567890"
       }
     end
-    @tarfile = 'data__/bla2.tar'
+    @tarfile = "data__/bla2.tar"
   end
 
   def teardown
-    FileUtils.rm_rf('data__')
+    FileUtils.rm_rf("data__")
   end
 
   def test_open_no_block
@@ -31,17 +31,17 @@ class TestTarOutput < Minitest::Test
 
   def test_file_looks_good
     Minitar::Output.open(@tarfile) do |os|
-      Dir.chdir('data__') do
+      Dir.chdir("data__") do
         NAMES.each do |name|
           stat = File.stat(name)
-          opts = { :size => stat.size, :mode => 0o644 }
+          opts = {:size => stat.size, :mode => 0o644}
           os.tar.add_file_simple(name, opts) do |ss|
-            File.open(name, 'rb') { |ff| ss.write(ff.read(4096)) until ff.eof? }
+            File.open(name, "rb") { |ff| ss.write(ff.read(4096)) until ff.eof? }
           end
         end
       end
     end
-    ff = File.open(@tarfile, 'rb')
+    ff = File.open(@tarfile, "rb")
     Minitar::Reader.open(ff) do |is|
       names_from_tar = is.map do |entry|
         entry.name

data/test/test_tar_reader.rb

@@ -1,15 +1,15 @@
 #!/usr/bin/env ruby
 
-require 'minitar'
-require 'minitest_helper'
+require "minitar"
+require "minitest_helper"
 
 class TestTarReader < Minitest::Test
   include Archive::Tar::Minitar::ByteSize
 
   def test_open_no_block
-    str = tar_file_header('lib/foo', '', 0o10644, 10) + "\0" * 512
-    str += tar_file_header('bar', 'baz', 0o644, 0)
-    str += tar_dir_header('foo', 'bar', 0o12345)
+    str = tar_file_header("lib/foo", "", 0o10644, 10) + "\0" * 512
+    str += tar_file_header("bar", "baz", 0o644, 0)
+    str += tar_dir_header("foo", "bar", 0o12345)
     str += "\0" * 1024
 
     reader = Minitar::Reader.open(StringIO.new(str))
@@ -20,13 +20,13 @@ class TestTarReader < Minitest::Test
   end
 
   def test_multiple_entries
-    str = tar_file_header('lib/foo', '', 0o10644, 10) + "\0" * 512
-    str += tar_file_header('bar', 'baz', 0o644, 0)
-    str += tar_dir_header('foo', 'bar', 0o12345)
-    str += tar_file_header('src/', '', 0o755, 0) # "file" with a trailing slash
+    str = tar_file_header("lib/foo", "", 0o10644, 10) + "\0" * 512
+    str += tar_file_header("bar", "baz", 0o644, 0)
+    str += tar_dir_header("foo", "bar", 0o12345)
+    str += tar_file_header("src/", "", 0o755, 0) # "file" with a trailing slash
     str += "\0" * 1024
-    names = %w(lib/foo bar foo src/)
-    prefixes = ['', 'baz', 'bar', '']
+    names = %w[lib/foo bar foo src/]
+    prefixes = ["", "baz", "bar", ""]
     modes = [0o10644, 0o644, 0o12345, 0o755]
     sizes = [10, 0, 0, 0]
     isdir = [false, false, true, true]
@@ -41,7 +41,7 @@ class TestTarReader < Minitest::Test
         assert_equal(modes[i], entry.mode)
         assert_equal(isdir[i], entry.directory?)
         assert_equal(isfile[i], entry.file?)
-        if prefixes[i] != ''
+        if prefixes[i] != ""
           assert_equal(File.join(prefixes[i], names[i]), entry.full_name)
         else
           assert_equal(names[i], entry.name)
@@ -53,8 +53,8 @@ class TestTarReader < Minitest::Test
   end
 
   def test_rewind_entry_works
-    content = ('a'..'z').to_a.join(' ')
-    str = tar_file_header('lib/foo', '', 0o10644, bytesize(content)) +
+    content = ("a".."z").to_a.join(" ")
+    str = tar_file_header("lib/foo", "", 0o10644, bytesize(content)) +
       content + "\0" * (512 - bytesize(content))
     str << "\0" * 1024
     Minitar::Reader.new(StringIO.new(str)) do |is|
@@ -69,8 +69,8 @@ class TestTarReader < Minitest::Test
   end
 
   def test_rewind_works
-    content = ('a'..'z').to_a.join(' ')
-    str = tar_file_header('lib/foo', '', 0o10644, bytesize(content)) +
+    content = ("a".."z").to_a.join(" ")
+    str = tar_file_header("lib/foo", "", 0o10644, bytesize(content)) +
       content + "\0" * (512 - bytesize(content))
     str << "\0" * 1024
     Minitar::Reader.new(StringIO.new(str)) do |is|
@@ -87,8 +87,8 @@ class TestTarReader < Minitest::Test
   end
 
   def test_read_works
-    contents = ('a'..'z').inject('') { |a, e| a << e * 100 }
-    str = tar_file_header('lib/foo', '', 0o10644, bytesize(contents)) + contents
+    contents = ("a".."z").inject("") { |a, e| a << e * 100 }
+    str = tar_file_header("lib/foo", "", 0o10644, bytesize(contents)) + contents
     str += "\0" * (512 - (bytesize(str) % 512))
     Minitar::Reader.new(StringIO.new(str)) do |is|
       is.each_entry do |entry|
@@ -122,7 +122,7 @@ class TestTarReader < Minitest::Test
   end
 
   def test_eof_works
-    str = tar_file_header('bar', 'baz', 0o644, 0)
+    str = tar_file_header("bar", "baz", 0o644, 0)
     Minitar::Reader.new(StringIO.new(str)) do |is|
       is.each_entry do |entry|
         assert_kind_of(Minitar::Reader::EntryStream, entry)
@@ -134,7 +134,7 @@ class TestTarReader < Minitest::Test
         assert_equal(true, entry.eof?)
       end
     end
-    str = tar_dir_header('foo', 'bar', 0o12345)
+    str = tar_dir_header("foo", "bar", 0o12345)
     Minitar::Reader.new(StringIO.new(str)) do |is|
       is.each_entry do |entry|
         assert_kind_of(Minitar::Reader::EntryStream, entry)
@@ -146,9 +146,9 @@ class TestTarReader < Minitest::Test
         assert_equal(true, entry.eof?)
       end
     end
-    str = tar_dir_header('foo', 'bar', 0o12345)
-    str += tar_file_header('bar', 'baz', 0o644, 0)
-    str += tar_file_header('bar', 'baz', 0o644, 0)
+    str = tar_dir_header("foo", "bar", 0o12345)
+    str += tar_file_header("bar", "baz", 0o644, 0)
+    str += tar_file_header("bar", "baz", 0o644, 0)
     Minitar::Reader.new(StringIO.new(str)) do |is|
       is.each_entry do |entry|
         assert_kind_of(Minitar::Reader::EntryStream, entry)

data/test/test_tar_writer.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
-require 'minitar'
-require 'minitest_helper'
+require "minitar"
+require "minitest_helper"
 
 class TestTarWriter < Minitest::Test
   include Archive::Tar::Minitar::ByteSize
@@ -21,15 +21,15 @@ class TestTarWriter < Minitest::Test
     end
 
     def reset
-      @data = ''
-      @data.force_encoding('ascii-8bit') if @data.respond_to?(:force_encoding)
+      @data = ""
+      @data.force_encoding("ascii-8bit") if @data.respond_to?(:force_encoding)
     end
   end
 
   def setup
-    @data = 'a' * 10
+    @data = "a" * 10
     @unicode = [0xc3.chr, 0xa5.chr].join * 10
-    @unicode.force_encoding('utf-8') if @unicode.respond_to?(:force_encoding)
+    @unicode.force_encoding("utf-8") if @unicode.respond_to?(:force_encoding)
     @dummyos = DummyIO.new
     @os = Minitar::Writer.new(@dummyos)
   end
@@ -46,63 +46,61 @@ class TestTarWriter < Minitest::Test
     assert writer.closed?
   end
 
-
   def test_add_file_simple
     @dummyos.reset
 
     Minitar::Writer.open(@dummyos) do |os|
-      os.add_file_simple('lib/foo/bar', :mode => 0o644, :size => 10) do |f|
-        f.write 'a' * 10
+      os.add_file_simple("lib/foo/bar", :mode => 0o644, :size => 10) do |f|
+        f.write "a" * 10
       end
-      os.add_file_simple('lib/bar/baz', :mode => 0o644, :size => 100) do |f|
-        f.write 'fillme'
+      os.add_file_simple("lib/bar/baz", :mode => 0o644, :size => 100) do |f|
+        f.write "fillme"
       end
     end
 
-    assert_headers_equal(tar_file_header('lib/foo/bar', '', 0o644, 10),
+    assert_headers_equal(tar_file_header("lib/foo/bar", "", 0o644, 10),
       @dummyos.data[0, 512])
-    assert_equal('a' * 10 + "\0" * 502, @dummyos.data[512, 512])
-    assert_headers_equal(tar_file_header('lib/bar/baz', '', 0o644, 100),
+    assert_equal("a" * 10 + "\0" * 502, @dummyos.data[512, 512])
+    assert_headers_equal(tar_file_header("lib/bar/baz", "", 0o644, 100),
       @dummyos.data[512 * 2, 512])
-    assert_equal('fillme' + "\0" * 506, @dummyos.data[512 * 3, 512])
+    assert_equal("fillme" + "\0" * 506, @dummyos.data[512 * 3, 512])
     assert_equal("\0" * 512, @dummyos.data[512 * 4, 512])
     assert_equal("\0" * 512, @dummyos.data[512 * 5, 512])
   end
 
   def test_write_operations_fail_after_closed
     @dummyos.reset
-    @os.add_file_simple('sadd', :mode => 0o644, :size => 20) { |f| }
+    @os.add_file_simple("sadd", :mode => 0o644, :size => 20) { |f| }
     @os.close
     assert_raises(Minitar::ClosedStream) { @os.flush }
-    assert_raises(Minitar::ClosedStream) {
-      @os.add_file('dfdsf', :mode => 0o644) {}
-    }
-    assert_raises(Minitar::ClosedStream) { @os.mkdir 'sdfdsf', :mode => 0o644 }
+    assert_raises(Minitar::ClosedStream) { @os.add_file("dfdsf", :mode => 0o644) {} }
+    assert_raises(Minitar::ClosedStream) { @os.mkdir "sdfdsf", :mode => 0o644 }
+    assert_raises(Minitar::ClosedStream) { @os.symlink "a", "b", :mode => 0o644 }
   end
 
   def test_file_name_is_split_correctly
     # test insane file lengths, and: a{100}/b{155}, etc
     @dummyos.reset
     names = [
-      "#{'a' * 155}/#{'b' * 100}",
-      "#{'a' * 151}/#{'qwer/' * 19}bla",
-      "/#{'a' * 49}/#{'b' * 50}",
-      "#{'a' * 49}/#{'b' * 50}x",
-      "#{'a' * 49}x/#{'b' * 50}"
+      "#{"a" * 155}/#{"b" * 100}",
+      "#{"a" * 151}/#{"qwer/" * 19}bla",
+      "/#{"a" * 49}/#{"b" * 50}",
+      "#{"a" * 49}/#{"b" * 50}x",
+      "#{"a" * 49}x/#{"b" * 50}"
     ]
     o_names = [
-      'b' * 100,
-      "#{'qwer/' * 19}bla",
-      'b' * 50,
-      "#{'b' * 50}x",
-      'b' * 50
+      "b" * 100,
+      "#{"qwer/" * 19}bla",
+      "b" * 50,
+      "#{"b" * 50}x",
+      "b" * 50
     ]
     o_prefixes = [
-      'a' * 155,
-      'a' * 151,
-      "/#{'a' * 49}",
-      'a' * 49,
-      "#{'a' * 49}x"
+      "a" * 155,
+      "a" * 151,
+      "/#{"a" * 49}",
+      "a" * 49,
+      "#{"a" * 49}x"
     ]
     names.each do |name|
       @os.add_file_simple(name, :mode => 0o644, :size => 10) {}
@@ -118,46 +116,83 @@ class TestTarWriter < Minitest::Test
   def test_file_name_is_long
     @dummyos.reset
 
-    @os.add_file_simple(File.join('a' * 152, 'b' * 10, 'c' * 92),
-                        :mode => 0o644, :size => 10) {}
-    @os.add_file_simple(File.join('d' * 162, 'e' * 10),
-                        :mode => 0o644, :size => 10) {}
-    @os.add_file_simple(File.join('f' * 10, 'g' * 110),
-                        :mode => 0o644, :size => 10) {}
+    @os.add_file_simple(File.join("a" * 152, "b" * 10, "c" * 92),
+      :mode => 0o644, :size => 10) {}
+    @os.add_file_simple(File.join("d" * 162, "e" * 10),
+      :mode => 0o644, :size => 10) {}
+    @os.add_file_simple(File.join("f" * 10, "g" * 110),
+      :mode => 0o644, :size => 10) {}
     # Issue #6.
-    @os.add_file_simple('a' * 114, :mode => 0o644, :size => 10) {}
+    @os.add_file_simple("a" * 114, :mode => 0o644, :size => 10) {}
 
     # "././@LongLink", a file name, its actual header, its data, ...
     4.times do |i|
       assert_equal(Minitar::PosixHeader::GNU_EXT_LONG_LINK,
-                   @dummyos.data[4 * i * 512, 32].rstrip)
+        @dummyos.data[4 * i * 512, 32].rstrip)
     end
   end
 
+  def test_add_file_simple_content_with_long_name
+    @dummyos.reset
+
+    long_name_file_content = "where_is_all_the_content_gone"
+
+    @os.add_file_simple("a" * 114, :mode => 0o0644, :data => long_name_file_content)
+
+    assert_equal(long_name_file_content,
+      @dummyos.data[3 * 512, long_name_file_content.bytesize])
+  end
+
+  def test_add_file_content_with_long_name
+    dummyos = StringIO.new
+    def dummyos.method_missing(meth, *a)
+      string.send(meth, *a)
+    end
+
+    def dummyos.respond_to_missing?(meth, all)
+      string.respond_to?(meth, all)
+    end
+
+    long_name_file_content = "where_is_all_the_content_gone"
+
+    Minitar::Writer.open(dummyos) do |os|
+      os.add_file("a" * 114, :mode => 0o0644) do |f|
+        f.write(long_name_file_content)
+      end
+    end
+
+    assert_equal(long_name_file_content,
+      dummyos[3 * 512, long_name_file_content.bytesize])
+  end
+
   def test_add_file
     dummyos = StringIO.new
-    def dummyos.method_missing(meth, *a) # rubocop:disable Style/MethodMissing
+    def dummyos.method_missing(meth, *a)
       string.send(meth, *a)
     end
-    content1 = ('a'..'z').to_a.join('') # 26
-    content2 = ('aa'..'zz').to_a.join('') # 1352
+
+    def dummyos.respond_to_missing?(meth, all)
+      string.respond_to?(meth, all)
+    end
+    content1 = ("a".."z").to_a.join("") # 26
+    content2 = ("aa".."zz").to_a.join("") # 1352
     Minitar::Writer.open(dummyos) do |os|
-      os.add_file('lib/foo/bar', :mode => 0o644) { |f, _opts| f.write 'a' * 10 }
-      os.add_file('lib/bar/baz', :mode => 0o644) { |f, _opts| f.write content1 }
-      os.add_file('lib/bar/baz', :mode => 0o644) { |f, _opts| f.write content2 }
-      os.add_file('lib/bar/baz', :mode => 0o644) { |_f, _opts| }
+      os.add_file("lib/foo/bar", :mode => 0o644) { |f, _opts| f.write "a" * 10 }
+      os.add_file("lib/bar/baz", :mode => 0o644) { |f, _opts| f.write content1 }
+      os.add_file("lib/bar/baz", :mode => 0o644) { |f, _opts| f.write content2 }
+      os.add_file("lib/bar/baz", :mode => 0o644) { |_f, _opts| }
     end
-    assert_headers_equal(tar_file_header('lib/foo/bar', '', 0o644, 10),
+    assert_headers_equal(tar_file_header("lib/foo/bar", "", 0o644, 10),
       dummyos[0, 512])
-    assert_equal(%Q(#{'a' * 10}#{"\0" * 502}), dummyos[512, 512])
+    assert_equal(%(#{"a" * 10}#{"\0" * 502}), dummyos[512, 512])
     offset = 512 * 2
-    [content1, content2, ''].each do |data|
-      assert_headers_equal(tar_file_header('lib/bar/baz', '', 0o644,
+    [content1, content2, ""].each do |data|
+      assert_headers_equal(tar_file_header("lib/bar/baz", "", 0o644,
         bytesize(data)), dummyos[offset, 512])
       offset += 512
-      until !data || data == ''
+      until !data || data == ""
         chunk = data[0, 512]
-        data[0, 512] = ''
+        data[0, 512] = ""
         assert_equal(chunk + "\0" * (512 - bytesize(chunk)),
           dummyos[offset, 512])
         offset += 512
@@ -168,28 +203,28 @@ class TestTarWriter < Minitest::Test
 
   def test_add_file_tests_seekability
     assert_raises(Archive::Tar::Minitar::NonSeekableStream) do
-      @os.add_file('libdfdsfd', :mode => 0o644) { |f| }
+      @os.add_file("libdfdsfd", :mode => 0o644) { |f| }
     end
   end
 
   def test_write_header
     @dummyos.reset
-    @os.add_file_simple('lib/foo/bar', :mode => 0o644, :size => 0) {}
+    @os.add_file_simple("lib/foo/bar", :mode => 0o644, :size => 0) {}
     @os.flush
-    assert_headers_equal(tar_file_header('lib/foo/bar', '', 0o644, 0),
+    assert_headers_equal(tar_file_header("lib/foo/bar", "", 0o644, 0),
       @dummyos.data[0, 512])
     @dummyos.reset
-    @os.mkdir('lib/foo', :mode => 0o644)
-    assert_headers_equal(tar_dir_header('lib/foo', '', 0o644),
+    @os.mkdir("lib/foo", :mode => 0o644)
+    assert_headers_equal(tar_dir_header("lib/foo", "", 0o644),
       @dummyos.data[0, 512])
-    @os.mkdir('lib/bar', :mode => 0o644)
-    assert_headers_equal(tar_dir_header('lib/bar', '', 0o644),
+    @os.mkdir("lib/bar", :mode => 0o644)
+    assert_headers_equal(tar_dir_header("lib/bar", "", 0o644),
       @dummyos.data[512 * 1, 512])
   end
 
   def test_write_data
     @dummyos.reset
-    @os.add_file_simple('lib/foo/bar', :mode => 0o644, :size => 10) do |f|
+    @os.add_file_simple("lib/foo/bar", :mode => 0o644, :size => 10) do |f|
       f.write @data
     end
     @os.flush
@@ -203,10 +238,10 @@ class TestTarWriter < Minitest::Test
     if @unicode.respond_to?(:bytesize)
       assert_equal 10, @unicode.size
       assert_equal 20, @unicode.bytesize
-      @unicode.force_encoding('ascii-8bit')
+      @unicode.force_encoding("ascii-8bit")
     end
 
-    file = ['lib/foo/b', 0xc3.chr, 0xa5.chr, 'r'].join
+    file = ["lib/foo/b", 0xc3.chr, 0xa5.chr, "r"].join
 
     @os.add_file_simple(file, :mode => 0o644, :size => 20) do |f|
       f.write @unicode
@@ -219,10 +254,25 @@ class TestTarWriter < Minitest::Test
   def test_file_size_is_checked
     @dummyos.reset
     assert_raises(Minitar::Writer::WriteBoundaryOverflow) do
-      @os.add_file_simple('lib/foo/bar', :mode => 0o644, :size => 10) do |f|
-        f.write '1' * 100
+      @os.add_file_simple("lib/foo/bar", :mode => 0o644, :size => 10) do |f|
+        f.write "1" * 100
       end
     end
-    @os.add_file_simple('lib/foo/bar', :mode => 0o644, :size => 10) { |f| }
+    @os.add_file_simple("lib/foo/bar", :mode => 0o644, :size => 10) { |f| }
+  end
+
+  def test_symlink
+    @dummyos.reset
+    @os.symlink("lib/foo/bar", "lib/foo/baz", :mode => 0o644)
+    @os.flush
+    assert_headers_equal(tar_symlink_header("lib/foo/bar", "", 0o644, "lib/foo/baz"),
+      @dummyos.data[0, 512])
+  end
+
+  def test_symlink_target_size_is_checked
+    @dummyos.reset
+    assert_raises(Minitar::FileNameTooLong) do
+      @os.symlink("lib/foo/bar", "x" * 101)
+    end
   end
 end