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