minitar 1.0.2 → 1.1.0

data/test/test_tar_header.rb

@@ -1,110 +1,324 @@
+# frozen_string_literal: true
+
 require "minitest_helper"
 
 class TestTarHeader < Minitest::Test
   def test_arguments_are_checked
-    ph = Minitar::PosixHeader
-    assert_raises(ArgumentError) {
-      ph.new(name: "", size: "", mode: "")
-    }
-    assert_raises(ArgumentError) {
-      ph.new(name: "", size: "", prefix: "")
-    }
-    assert_raises(ArgumentError) {
-      ph.new(name: "", prefix: "", mode: "")
-    }
-    assert_raises(ArgumentError) {
-      ph.new(prefix: "", size: "", mode: "")
-    }
+    assert_raises(ArgumentError) { new(name: "", size: "", mode: "") }
+    assert_raises(ArgumentError) { new(name: "", size: "", prefix: "") }
+    assert_raises(ArgumentError) { new(name: "", prefix: "", mode: "") }
+    assert_raises(ArgumentError) { new(prefix: "", size: "", mode: "") }
   end
 
   def test_basic_headers
-    header = {
-      name: "bla",
-      mode: 0o12345,
-      size: 10,
-      prefix: "",
-      typeflag: "0"
-    }
-    assert_headers_equal(tar_file_header("bla", "", 0o12345, 10),
-      Minitar::PosixHeader.new(header).to_s)
-
-    header = {
-      name: "bla",
-      mode: 0o12345,
-      size: 0,
-      prefix: "",
-      typeflag: "5"
-    }
-    assert_headers_equal(tar_dir_header("bla", "", 0o12345),
-      Minitar::PosixHeader.new(header).to_s)
+    assert_headers_equal build_tar_file_header("bla", "", 0o12345, 10),
+      new(
+        name: "bla",
+        mode: 0o12345,
+        size: 10,
+        prefix: "",
+        typeflag: "0"
+      )
+
+    assert_headers_equal build_tar_dir_header("bla", "", 0o12345),
+      new(
+        name: "bla",
+        mode: 0o12345,
+        size: 0,
+        prefix: "",
+        typeflag: "5"
+      )
   end
 
   def test_long_name_works
-    header = {
-      name: "a" * 100, mode: 0o12345, size: 10, prefix: ""
-    }
-    assert_headers_equal(tar_file_header("a" * 100, "", 0o12345, 10),
-      Minitar::PosixHeader.new(header).to_s)
-    header = {
-      name: "a" * 100, mode: 0o12345, size: 10, prefix: "bb" * 60
-    }
-    assert_headers_equal(tar_file_header("a" * 100, "bb" * 60, 0o12345, 10),
-      Minitar::PosixHeader.new(header).to_s)
+    assert_headers_equal build_tar_file_header("a" * 100, "", 0o12345, 10),
+      new(name: "a" * 100, mode: 0o12345, size: 10, prefix: "")
+
+    assert_headers_equal build_tar_file_header("a" * 100, "bb" * 60, 0o12345, 10),
+      new(name: "a" * 100, mode: 0o12345, size: 10, prefix: "bb" * 60)
   end
 
   def test_from_stream
-    header = tar_file_header("a" * 100, "", 0o12345, 10)
-    header = StringIO.new(header)
-    h = Minitar::PosixHeader.from_stream(header)
-    assert_equal "a" * 100, h.name
-    assert_equal 0o12345, h.mode
-    assert_equal 10, h.size
-    assert_equal "", h.prefix
-    assert_equal "ustar", h.magic
+    header = from_stream(
+      build_tar_file_header("a" * 100, "", 0o12345, 10)
+    )
+
+    assert_equal "a" * 100, header.name
+    assert_equal 0o12345, header.mode
+    assert_equal 10, header.size
+    assert_equal "", header.prefix
+    assert_equal "ustar", header.magic
   end
 
   def test_from_stream_with_evil_name
-    header = tar_file_header("a \0" + "\0" * 97, "", 0o12345, 10)
-    header = StringIO.new(header)
-    h = Minitar::PosixHeader.from_stream header
-    assert_equal "a ", h.name
+    assert_equal "a ", from_stream(
+      build_tar_file_header("a \0" + "\0" * 97, "", 0o12345, 10)
+    ).name
   end
 
   def test_valid_with_valid_header
-    header = tar_file_header("a" * 100, "", 0o12345, 10)
-    header = StringIO.new(header)
-    h = Minitar::PosixHeader.from_stream header
-
-    assert(h.valid?)
+    assert from_stream(
+      build_tar_file_header("a" * 100, "", 0o12345, 10)
+    ).valid?
   end
 
   def test_from_stream_with_no_strict_octal
-    header = tar_file_header("a" * 100, "", 0o12345, -1213)
-    io = StringIO.new(header)
-
     assert_raises(ArgumentError) do
-      Minitar::PosixHeader.from_stream(io)
+      from_stream(
+        build_tar_file_header("a" * 100, "", 0o12345, -1213)
+      )
     end
   end
 
   def test_from_stream_with_octal_wrapped_by_spaces
-    header = raw_header(0,
-      asciiz("a" * 100, 100),
-      asciiz("", 155),
-      "       1213\0",
-      z(to_oct(0o12345, 7)))
+    assert_equal 651, from_stream(
+      update_header_checksum(
+        build_raw_header(
+          0,
+          asciiz("a" * 100, 100),
+          asciiz("", 155),
+          "       1213\0",
+          z(octal(0o12345, 7))
+        )
+      )
+    ).size
+  end
+
+  def test_valid_with_invalid_header
+    refute from_stream("invalid").valid?
+  end
+
+  def test_setting_long_name_assigns_complete_path
+    header = new(
+      name: "short.txt",
+      mode: 0o644,
+      size: 100,
+      prefix: "some/directory/path"
+    )
+
+    complete_path = "some/directory/path/very_long_filename_that_exceeds_one_hundred_characters_and_needs_gnu_extension.txt"
+    header.long_name = complete_path
+
+    assert_equal complete_path, header.name
+  end
+
+  def test_setting_long_name_clears_prefix_field
+    header = new(
+      name: "short.txt",
+      mode: 0o644,
+      size: 100,
+      prefix: "some/directory/path"
+    )
+
+    complete_path = "some/directory/path/very_long_filename_that_exceeds_one_hundred_characters_and_needs_gnu_extension.txt"
+    header.long_name = complete_path
+
+    assert_equal "", header.prefix
+  end
+
+  def test_setting_long_name_with_nested_directories
+    header = new(
+      name: "file.txt",
+      mode: 0o644,
+      size: 50,
+      prefix: "old/prefix"
+    )
+
+    complete_path = "deep/nested/directory/structure/with/very_long_filename_that_needs_gnu_long_name_extension_support.txt"
+    header.long_name = complete_path
+
+    assert_equal complete_path, header.name
+    assert_equal "", header.prefix
+  end
+
+  def test_setting_long_name_with_empty_prefix
+    header = new(
+      name: "file.txt",
+      mode: 0o644,
+      size: 50,
+      prefix: ""
+    )
+
+    complete_path = "very_long_filename_that_exceeds_one_hundred_characters_and_definitely_needs_gnu_extension_support.txt"
+    header.long_name = complete_path
+
+    assert_equal complete_path, header.name
+    assert_equal "", header.prefix
+  end
+
+  def test_gnu_long_names_extension_is_detected
+    assert new(
+      name: Minitar::PosixHeader::GNU_EXT_LONG_LINK,
+      mode: 0o644,
+      size: 150,
+      prefix: "",
+      typeflag: "L"
+    ).long_name?
+  end
+
+  def test_setting_long_name_with_very_long_path
+    header = new(
+      name: "file.txt",
+      mode: 0o644,
+      size: 100,
+      prefix: "old/prefix"
+    )
+
+    long_dir = "very_long_directory_name_that_exceeds_normal_limits" * 5
+    complete_path = "#{long_dir}/extremely_long_filename_with_many_characters.txt"
+    header.long_name = complete_path
+
+    assert_equal complete_path, header.name
+    assert_equal "", header.prefix
+  end
+
+  def test_setting_long_name_with_single_filename_no_directories
+    header = new(
+      name: "short.txt",
+      mode: 0o644,
+      size: 100,
+      prefix: "some/existing/prefix"
+    )
+
+    complete_path = "extremely_long_single_filename_without_any_directory_structure_that_exceeds_one_hundred_characters.txt"
+    header.long_name = complete_path
+
+    assert_equal complete_path, header.name
+    assert_equal "", header.prefix
+  end
 
-    header = update_checksum(header)
+  def test_setting_long_name_preserves_other_header_fields
+    header = new(
+      name: "short.txt",
+      mode: 0o755,
+      size: 12345,
+      prefix: "old/prefix",
+      uid: 1000,
+      gid: 1000,
+      mtime: 1234567890,
+      typeflag: "0",
+      linkname: "some_link"
+    )
+
+    complete_path = "new/very_long_path/that_exceeds_one_hundred_characters_and_needs_gnu_extension_support.txt"
+    header.long_name = complete_path
+
+    assert_equal complete_path, header.name
+    assert_equal "", header.prefix
+
+    assert_equal 0o755, header.mode
+    assert_equal 12345, header.size
+    assert_equal 1000, header.uid
+    assert_equal 1000, header.gid
+    assert_equal 1234567890, header.mtime
+    assert_equal "0", header.typeflag
+    assert_equal "some_link", header.linkname
+  end
+
+  def test_setting_name_with_empty_string
+    header = new(
+      name: "short.txt",
+      mode: 0o644,
+      size: 100,
+      prefix: "some/prefix"
+    )
+
+    assert_raises(ArgumentError) do
+      header.name = ""
+    end
+  end
+
+  def test_setting_long_name_with_empty_string
+    header = new(
+      name: "short.txt",
+      mode: 0o644,
+      size: 100,
+      prefix: "some/prefix"
+    )
+
+    assert_raises(ArgumentError) do
+      header.long_name = ""
+    end
+  end
+
+  def test_new_with_empty_string
+    assert_raises(ArgumentError) do
+      new(
+        name: "",
+        mode: 0o644,
+        size: 100,
+        prefix: "some/prefix"
+      )
+    end
+  end
+
+  def test_parse_numeric_field_octal
+    ph = Minitar::PosixHeader
+    assert_equal 123, ph.send(:parse_numeric_field, "173")
+    assert_equal 0, ph.send(:parse_numeric_field, "0")
+    assert_equal 511, ph.send(:parse_numeric_field, "777")
+  end
+
+  def test_parse_numeric_field_octal_with_spaces
+    ph = Minitar::PosixHeader
+    assert_equal 123, ph.send(:parse_numeric_field, "  173  ")
+    assert_equal 0, ph.send(:parse_numeric_field, "       ")
+  end
+
+  def test_parse_numeric_field_binary_positive_number
+    binary_data = [0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x34, 0x56, 0x78, 0x9A].pack("C*")
+
+    header = build_raw_header(
+      0,
+      asciiz("large_file.bin", 100),
+      asciiz("", 155),
+      binary_data,
+      z(octal(0o12345, 7))
+    )
+    header = update_header_checksum(header)
     io = StringIO.new(header)
-    header = Minitar::PosixHeader.from_stream(io)
+    h = Minitar::PosixHeader.from_stream(io)
 
-    assert_equal 651, header.size
+    expected_size = 0x123456789A
+    assert_equal expected_size, h.size
   end
 
-  def test_valid_with_invalid_header
-    header = StringIO.new("testing")
-    h = Minitar::PosixHeader.from_stream header
+  def test_parse_numeric_field_binary_negative_number
+    binary_data = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF].pack("C*")
+
+    header = build_raw_header(
+      0,
+      asciiz("negative_size.bin", 100),
+      asciiz("", 155),
+      binary_data,
+      z(octal(0o12345, 7))
+    )
+
+    header = update_header_checksum(header)
+    io = StringIO.new(header)
+    h = Minitar::PosixHeader.from_stream(io)
 
-    refute(h.valid?)
+    expected_size = -1
+    assert_equal expected_size, h.size
   end
+
+  def test_parse_numeric_field_invalid
+    ph = Minitar::PosixHeader
+    assert_raises(ArgumentError) do
+      ph.send(:parse_numeric_field, "invalid")
+    end
+    assert_raises(ArgumentError) do
+      ph.send(:parse_numeric_field, "\x01\x02\x03")  # Invalid binary format
+    end
+  end
+
+  private
+
+  def from_stream(stream) =
+    stream
+      .then { _1.is_a?(String) ? StringIO.new(_1) : _1 }
+      .then { Minitar::PosixHeader.from_stream(_1) }
+
+  def new(header_hash) =
+    Minitar::PosixHeader.new(header_hash)
 end

data/test/test_tar_input.rb

@@ -1,23 +1,8 @@
-#!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require "minitar"
 require "minitest_helper"
-require "base64"
-require "zlib"
 
 class TestTarInput < Minitest::Test
-  TEST_TGZ = Base64.decode64(<<~EOS).freeze
-    H4sIAKJpllQAA0tJLEnUK0ks0kuvYqAVMDAwMDMxUQDR5mbmYNrACMIHA2MjIwUDc3NzEzMz
-    QxMDAwUDQ2NTczMGBQOauQgJlBYDfQ90SiKQkZmHWx1QWVoaHnMgXlGA00MEyHdzMMzOnBbC
-    wPz28n2uJgOR44Xrq7tsHc/utNe/9FdihkmH3pZ7+zOTRFREzkzYJ99iHHDn4n0/Wb3E8Ceq
-    S0uOdSyMMg9Z+WVvX0vJucxs77vrvZf2arWcvHP9wa1Yp9lRnJmC59/P9+43PXum+tj7Ga+8
-    rtT+u3d941e765Y/bOrnvpv8X6jtz+wKqyk/v3n8P5xlO3l/1dn9q9Zotpy5funw/Of77Y/5
-    LVltz7ToTl7dXf5ppmf3n9p+PPxz/sz/qjZn9yf9Y4R7I2Ft3tqfPTUMGgMYlEMSpGXmpBrT
-    2A5Qvjc1xZ3/DTDyv5GJmfFo/qcHCMnILFYAIlA6UDDWU+DlGmgXjYJRMApGwSgYBaNgFIyC
-    UTAKRsEoGAWjYBSMglEwCkbBKBgFo2AUjIJRMApGwSgYBaNgFIwCUgAAGnyo6wAoAAA=
-  EOS
-  FILETIMES = Time.utc(2004).to_i
-
   TEST_CONTENTS = {
     "data.tar.gz" => {size: 210, mode: 0o644},
     "file3" => {size: 18, mode: 0o755}
@@ -31,16 +16,17 @@ class TestTarInput < Minitest::Test
   }.freeze
 
   def setup
+    @reader = open_fixture("tar_input")
     FileUtils.mkdir_p("data__")
   end
 
   def teardown
+    @reader&.close unless @reader&.closed?
     FileUtils.rm_rf("data__")
   end
 
   def test_open_no_block
-    reader = Zlib::GzipReader.new(StringIO.new(TEST_TGZ))
-    input = Minitar::Input.open(reader)
+    input = Minitar::Input.open(@reader)
     refute input.closed?
   ensure
     input.close
@@ -48,8 +34,7 @@ class TestTarInput < Minitest::Test
   end
 
   def test_each_works
-    reader = Zlib::GzipReader.new(StringIO.new(TEST_TGZ))
-    Minitar::Input.open(reader) do |stream|
+    Minitar::Input.open(@reader) do |stream|
       outer = 0
       stream.each.with_index do |entry, i|
         assert_kind_of Minitar::Reader::EntryStream, entry
@@ -58,7 +43,7 @@ class TestTarInput < Minitest::Test
         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 TIME_2004, entry.mtime, "entry.mtime"
 
         if i.zero?
           data_reader = Zlib::GzipReader.new(StringIO.new(entry.read))
@@ -71,7 +56,7 @@ class TestTarInput < Minitest::Test
                 entry2.name)
               assert_modes_equal(TEST_DATA_CONTENTS[entry2.name][:mode],
                 entry2.mode, entry2.name)
-              assert_equal FILETIMES, entry2.mtime, entry2.name
+              assert_equal TIME_2004, entry2.mtime, entry2.name
               inner += 1
             end
             assert_equal 4, inner
@@ -86,8 +71,7 @@ class TestTarInput < Minitest::Test
   end
 
   def test_extract_entry_works
-    reader = Zlib::GzipReader.new(StringIO.new(TEST_TGZ))
-    Minitar::Input.open(reader) do |stream|
+    Minitar::Input.open(@reader) do |stream|
       outer_count = 0
       stream.each_with_index do |entry, i|
         stream.extract_entry("data__", entry)
@@ -150,7 +134,7 @@ class TestTarInput < Minitest::Test
     File.symlink("data__/file4", "data__/file3")
     File.symlink("data__/file4", "data__/data")
 
-    Minitar.unpack(Zlib::GzipReader.new(StringIO.new(TEST_TGZ)), "data__")
+    Minitar.unpack(@reader, "data__")
     Minitar.unpack(Zlib::GzipReader.new(File.open("data__/data.tar.gz", "rb")),
       "data__")
 
@@ -158,13 +142,8 @@ class TestTarInput < Minitest::Test
     refute File.symlink?("data__/data")
   end
 
-  RELATIVE_DIRECTORY_TGZ = Base64.decode64 <<~EOS
-    H4sICIIoKVgCA2JhZC1kaXIudGFyANPT0y8sTy0qqWSgHTAwMDAzMVEA0eZmpmDawAjChwEFQ2MDQyMg
-    MDUzVDAwNDY0N2VQMGCgAygtLkksAjolEcjIzMOtDqgsLQ2/J0H+gNOjYBSMglEwyAEA2LchrwAGAAA=
-  EOS
-
   def test_extract_entry_fails_with_relative_directory
-    reader = Zlib::GzipReader.new(StringIO.new(RELATIVE_DIRECTORY_TGZ))
+    reader = open_fixture("test_input_relative")
     Minitar::Input.open(reader) do |stream|
       stream.each do |entry|
         assert_raises Minitar::SecureRelativePathError do
@@ -174,52 +153,26 @@ class TestTarInput < Minitest::Test
     end
   end
 
-  NON_STRICT_OCTAL_TGZ = Base64.decode64(<<~EOS).freeze
-    H4sIAEk55FsAA0tJLEnUK0ks0kuvYqAVMDAwMDMxUQDR5mbmYNrACMjX0zMH
-    AzMDUwUDIG1iZmZoYmCgYGBobGpuxqBgQDMXIYHSYqDvgU5KBDIy83CrAypL
-    S8NjjgEYKMDpIQLkuzkYZmdOC2Fgfnv5PleTgcjxwvXVXbaOZ3fa61/6KzHD
-    pENvy739mUkiKiJnJuyTbzEOuHPxvp+sXmL4E9WlJcc6FkaZh6z8srevpeRc
-    Zrb33fXeS3u1Wk7euf7gVqzT7CjOTMHz7+d795uePVN97P2MV15Xav/du77x
-    q911yx829XPfTf4v1PZndoXVlJ/fPP4fzrKdvL/q7P5VazRbzly/dHj+8/32
-    x/yWrLZnWnQnr+4u/zTTs/tPbT8e/jl/5n9Vm7P7k/4xwr2RsDZv7c+eGgaN
-    AQzKIQnSMnNSjWlsByjfm5pi5n8DGDAyQsv/RiZmxqP5nx4gJCOzWAGIQOlA
-    wVhPgZdroF00CkbBKBgFo2AUjIJRMApGwSgYBaNgFIyCUTAKRsEoGAWjYBSM
-    glEwCkbBKBgFo2AUjIJRMApIAQD0DyzXACgAAA==
-  EOS
-
   def test_extract_with_non_strict_octal
-    reader = Zlib::GzipReader.new(StringIO.new(NON_STRICT_OCTAL_TGZ))
+    reader = open_fixture("test_input_non_strict_octal")
 
     assert_raises(ArgumentError) do
       Minitar.unpack(reader, "data__")
     end
   end
 
-  OCTAL_WRAPPED_BY_SPACE_TGZ = Base64.decode64(<<~EOS).freeze
-    H4sIAOQg5FsAA0tJLEnUK0ks0kuvYqAVMDAwMDMxUQDR5mbmYNrACMhXgAJj
-    IyMFA3NzcxMzM0MTAwMFA0NjU3MzBgUDmrkICZQWA30PdFIikJGZh1sdUFla
-    Gh5zDMBAAU4PESDfzcEwO3NaCAPz28v3uZoMRI4Xrq/usnU8u9Ne/9JfiRkm
-    HXpb7u3PTBJRETkzYZ98i3HAnYv3/WT1EsOfqC4tOdaxMMo8ZOWXvX0tJecy
-    s73vrvde2qvVcvLO9Qe3Yp1mR3FmCp5/P9+73/Tsmepj72e88rpS++/e9Y1f
-    7a5b/rCpn/tu8n+htj+zK6ym/Pzm8f9wlu3k/VVn969ao9ly5vqlw/Of77c/
-    5rdktT3Tojt5dXf5p5me3X9q+/Hwz/kz/6vanN2f9I8R7o2EtXlrf/bUMGgM
-    YFAOSZCWmZNqTGM7QPne1BQz/xvAAEb+NzIxMx7N//QAIRmZxQpABEoHCsZ6
-    CrxcA+2iUTAKRsEoGAWjYBSMglEwCkbBKBgFo2AUjIJRMApGwSgYBaNgFIyC
-    UTAKRsEoGAWjYBSMglFACgAAuUHUvwAoAAA=
-  EOS
-
   def test_extract_octal_wrapped_by_space
-    reader = Zlib::GzipReader.new(StringIO.new(OCTAL_WRAPPED_BY_SPACE_TGZ))
+    reader = open_fixture("test_input_space_octal")
     header = Minitar::PosixHeader.from_stream(reader)
     assert_equal 210, header.size
 
-    reader = Zlib::GzipReader.new(StringIO.new(OCTAL_WRAPPED_BY_SPACE_TGZ))
+    reader = open_fixture("test_input_space_octal")
     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(@reader, "data__", [], fsync: false) do |_label, _path, _stats|
       outer += 1
     end
     assert_equal 6, outer

data/test/test_tar_output.rb

@@ -1,6 +1,5 @@
-#!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require "minitar"
 require "minitest_helper"
 
 class TestTarOutput < Minitest::Test
@@ -31,13 +30,12 @@ class TestTarOutput < Minitest::Test
 
   def test_file_looks_good
     Minitar::Output.open(@tarfile) do |os|
-      Dir.chdir("data__") do
-        NAMES.each do |name|
-          stat = File.stat(name)
-          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? }
-          end
+      NAMES.each do |name|
+        filename = File.join("data__", name)
+        stat = File.stat(filename)
+        opts = {size: stat.size, mode: 0o644}
+        os.tar.add_file_simple(name, opts) do |ss|
+          File.open(filename, "rb") { |ff| ss.write(ff.read(4096)) until ff.eof? }
         end
       end
     end

data/test/test_tar_reader.rb

@@ -1,13 +1,12 @@
-#!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require "minitar"
 require "minitest_helper"
 
 class TestTarReader < Minitest::Test
   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 = build_tar_file_header("lib/foo", "", 0o10644, 10) + "\0" * 512
+    str += build_tar_file_header("bar", "baz", 0o644, 0)
+    str += build_tar_dir_header("foo", "bar", 0o12345)
     str += "\0" * 1024
 
     reader = Minitar::Reader.open(StringIO.new(str))
@@ -18,10 +17,10 @@ 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 = build_tar_file_header("lib/foo", "", 0o10644, 10) + "\0" * 512
+    str += build_tar_file_header("bar", "baz", 0o644, 0)
+    str += build_tar_dir_header("foo", "bar", 0o12345)
+    str += build_tar_file_header("src/", "", 0o755, 0) # "file" with a trailing slash
     str += "\0" * 1024
     names = %w[lib/foo bar foo src/]
     prefixes = ["", "baz", "bar", ""]
@@ -52,7 +51,7 @@ class TestTarReader < Minitest::Test
 
   def test_rewind_entry_works
     content = ("a".."z").to_a.join(" ")
-    str = tar_file_header("lib/foo", "", 0o10644, content.bytesize) +
+    str = build_tar_file_header("lib/foo", "", 0o10644, content.bytesize) +
       content + "\0" * (512 - content.bytesize)
     str << "\0" * 1024
     Minitar::Reader.new(StringIO.new(str)) do |is|
@@ -68,7 +67,7 @@ class TestTarReader < Minitest::Test
 
   def test_rewind_works
     content = ("a".."z").to_a.join(" ")
-    str = tar_file_header("lib/foo", "", 0o10644, content.bytesize) +
+    str = build_tar_file_header("lib/foo", "", 0o10644, content.bytesize) +
       content + "\0" * (512 - content.bytesize)
     str << "\0" * 1024
     Minitar::Reader.new(StringIO.new(str)) do |is|
@@ -85,8 +84,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, contents.bytesize) + contents
+    contents = ("a".."z").inject(+"") { |a, e| a << e * 100 }
+    str = build_tar_file_header("lib/foo", "", 0o10644, contents.bytesize) + contents
     str += "\0" * (512 - (str.bytesize % 512))
     Minitar::Reader.new(StringIO.new(str)) do |is|
       is.each_entry do |entry|
@@ -120,7 +119,7 @@ class TestTarReader < Minitest::Test
   end
 
   def test_eof_works
-    str = tar_file_header("bar", "baz", 0o644, 0)
+    str = build_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
@@ -132,7 +131,7 @@ class TestTarReader < Minitest::Test
         assert entry.eof?
       end
     end
-    str = tar_dir_header("foo", "bar", 0o12345)
+    str = build_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
@@ -144,9 +143,9 @@ class TestTarReader < Minitest::Test
         assert 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 = build_tar_dir_header("foo", "bar", 0o12345)
+    str += build_tar_file_header("bar", "baz", 0o644, 0)
+    str += build_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