unittests/Support/TarWriterTest.cpp

   1 //===- llvm/unittest/Support/TarWriterTest.cpp ----------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "llvm/Support/TarWriter.h"
  11 #include "llvm/Support/FileSystem.h"
  12 #include "llvm/Support/MemoryBuffer.h"
  13 #include "gtest/gtest.h"
  14 #include <vector>
  15
  16 using namespace llvm;
  17 namespace {
  18
  19 struct UstarHeader {
  20   char Name[100];
  21   char Mode[8];
  22   char Uid[8];
  23   char Gid[8];
  24   char Size[12];
  25   char Mtime[12];
  26   char Checksum[8];
  27   char TypeFlag;
  28   char Linkname[100];
  29   char Magic[6];
  30   char Version[2];
  31   char Uname[32];
  32   char Gname[32];
  33   char DevMajor[8];
  34   char DevMinor[8];
  35   char Prefix[155];
  36   char Pad[12];
  37 };
  38
  39 class TarWriterTest : public ::testing::Test {};
  40
  41 static std::vector<uint8_t> createTar(StringRef Base, StringRef Filename) {
  42   // Create a temporary file.
  43   SmallString<128> Path;
  44   std::error_code EC =
  45       sys::fs::createTemporaryFile("TarWriterTest", "tar", Path);
  46   EXPECT_FALSE((bool)EC);
  47
  48   // Create a tar file.
  49   Expected<std::unique_ptr<TarWriter>> TarOrErr = TarWriter::create(Path, Base);
  50   EXPECT_TRUE((bool)TarOrErr);
  51   std::unique_ptr<TarWriter> Tar = std::move(*TarOrErr);
  52   Tar->append(Filename, "contents");
  53   Tar.reset();
  54
  55   // Read the tar file.
  56   ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr = MemoryBuffer::getFile(Path);
  57   EXPECT_TRUE((bool)MBOrErr);
  58   std::unique_ptr<MemoryBuffer> MB = std::move(*MBOrErr);
  59   std::vector<uint8_t> Buf((const uint8_t *)MB->getBufferStart(),
  60                            (const uint8_t *)MB->getBufferEnd());
  61
  62   // Windows does not allow us to remove a mmap'ed files, so
  63   // unmap first and then remove the temporary file.
  64   MB = nullptr;
  65   sys::fs::remove(Path);
  66
  67   return Buf;
  68 }
  69
  70 static UstarHeader createUstar(StringRef Base, StringRef Filename) {
  71   std::vector<uint8_t> Buf = createTar(Base, Filename);
  72   EXPECT_TRUE(Buf.size() >= sizeof(UstarHeader));
  73   return *reinterpret_cast<const UstarHeader *>(Buf.data());
  74 }
  75
  76 TEST_F(TarWriterTest, Basics) {
  77   UstarHeader Hdr = createUstar("base", "file");
  78   EXPECT_EQ("ustar", StringRef(Hdr.Magic));
  79   EXPECT_EQ("00", StringRef(Hdr.Version, 2));
  80   EXPECT_EQ("base/file", StringRef(Hdr.Name));
  81   EXPECT_EQ("00000000010", StringRef(Hdr.Size));
  82 }
  83
  84 TEST_F(TarWriterTest, LongFilename) {
  85   std::string x154(154, 'x');
  86   std::string x155(155, 'x');
  87   std::string y99(99, 'y');
  88   std::string y100(100, 'y');
  89
  90   UstarHeader Hdr1 = createUstar("", x154 + "/" + y99);
  91   EXPECT_EQ("/" + x154, StringRef(Hdr1.Prefix));
  92   EXPECT_EQ(y99, StringRef(Hdr1.Name));
  93
  94   UstarHeader Hdr2 = createUstar("", x155 + "/" + y99);
  95   EXPECT_EQ("", StringRef(Hdr2.Prefix));
  96   EXPECT_EQ("", StringRef(Hdr2.Name));
  97
  98   UstarHeader Hdr3 = createUstar("", x154 + "/" + y100);
  99   EXPECT_EQ("", StringRef(Hdr3.Prefix));
 100   EXPECT_EQ("", StringRef(Hdr3.Name));
 101
 102   UstarHeader Hdr4 = createUstar("", x155 + "/" + y100);
 103   EXPECT_EQ("", StringRef(Hdr4.Prefix));
 104   EXPECT_EQ("", StringRef(Hdr4.Name));
 105
 106   std::string yz = "yyyyyyyyyyyyyyyyyyyy/zzzzzzzzzzzzzzzzzzzz";
 107   UstarHeader Hdr5 = createUstar("", x154 + "/" + yz);
 108   EXPECT_EQ("/" + x154, StringRef(Hdr5.Prefix));
 109   EXPECT_EQ(yz, StringRef(Hdr5.Name));
 110 }
 111
 112 TEST_F(TarWriterTest, Pax) {
 113   std::vector<uint8_t> Buf = createTar("", std::string(200, 'x'));
 114   EXPECT_TRUE(Buf.size() >= 1024);
 115
 116   auto *Hdr = reinterpret_cast<const UstarHeader *>(Buf.data());
 117   EXPECT_EQ("", StringRef(Hdr->Prefix));
 118   EXPECT_EQ("", StringRef(Hdr->Name));
 119
 120   StringRef Pax = StringRef((char *)(Buf.data() + 512), 512);
 121   EXPECT_TRUE(Pax.startswith("211 path=/" + std::string(200, 'x')));
 122 }
 123
 124 TEST_F(TarWriterTest, SingleFile) {
 125   SmallString<128> Path;
 126   std::error_code EC =
 127       sys::fs::createTemporaryFile("TarWriterTest", "tar", Path);
 128   EXPECT_FALSE((bool)EC);
 129
 130   Expected<std::unique_ptr<TarWriter>> TarOrErr = TarWriter::create(Path, "");
 131   EXPECT_TRUE((bool)TarOrErr);
 132   std::unique_ptr<TarWriter> Tar = std::move(*TarOrErr);
 133   Tar->append("FooPath", "foo");
 134   Tar.reset();
 135
 136   uint64_t TarSize;
 137   EC = sys::fs::file_size(Path, TarSize);
 138   EXPECT_FALSE((bool)EC);
 139   EXPECT_EQ(TarSize, 2048ULL);
 140 }
 141
 142 TEST_F(TarWriterTest, NoDuplicate) {
 143   SmallString<128> Path;
 144   std::error_code EC =
 145       sys::fs::createTemporaryFile("TarWriterTest", "tar", Path);
 146   EXPECT_FALSE((bool)EC);
 147
 148   Expected<std::unique_ptr<TarWriter>> TarOrErr = TarWriter::create(Path, "");
 149   EXPECT_TRUE((bool)TarOrErr);
 150   std::unique_ptr<TarWriter> Tar = std::move(*TarOrErr);
 151   Tar->append("FooPath", "foo");
 152   Tar->append("BarPath", "bar");
 153   Tar.reset();
 154
 155   uint64_t TarSize;
 156   EC = sys::fs::file_size(Path, TarSize);
 157   EXPECT_FALSE((bool)EC);
 158   EXPECT_EQ(TarSize, 3072ULL);
 159 }
 160
 161 TEST_F(TarWriterTest, Duplicate) {
 162   SmallString<128> Path;
 163   std::error_code EC =
 164       sys::fs::createTemporaryFile("TarWriterTest", "tar", Path);
 165   EXPECT_FALSE((bool)EC);
 166
 167   Expected<std::unique_ptr<TarWriter>> TarOrErr = TarWriter::create(Path, "");
 168   EXPECT_TRUE((bool)TarOrErr);
 169   std::unique_ptr<TarWriter> Tar = std::move(*TarOrErr);
 170   Tar->append("FooPath", "foo");
 171   Tar->append("FooPath", "bar");
 172   Tar.reset();
 173
 174   uint64_t TarSize;
 175   EC = sys::fs::file_size(Path, TarSize);
 176   EXPECT_FALSE((bool)EC);
 177   EXPECT_EQ(TarSize, 2048ULL);
 178 }
 179 } // namespace