#include <apt-pkg/error.h>
#include <apt-pkg/fileutl.h>
+#include <apt-pkg/strutl.h>
#include <apt-pkg/aptconfiguration.h>
#include <string>
#include <vector>
#include <stdlib.h>
-#include <sys/stat.h>
#include <string.h>
-#include "assert.h"
+#include <gtest/gtest.h>
-static void assertStringEquals(char const * const expect, char const * const got, unsigned long const line) {
- if (strncmp(expect, got, strlen(expect)) == 0)
- return;
- OutputAssertEqual(expect, "==", got, line);
-}
-#define strequals(x,y) assertStringEquals(x, y, __LINE__)
+#include "file-helpers.h"
-static bool
-TestFileFd(mode_t const a_umask, mode_t const ExpectedFilePermission, unsigned int const filemode, APT::Configuration::Compressor const &compressor)
+static void TestFileFd(mode_t const a_umask, mode_t const ExpectedFilePermission,
+ unsigned int const filemode, APT::Configuration::Compressor const &compressor)
{
- FileFd f;
- struct stat buf;
- static const char* fname = "test.txt";
+ std::string trace;
+ strprintf(trace, "TestFileFd: Compressor: %s umask: %#o permission: %#o mode: %d", compressor.Name.c_str(), a_umask, ExpectedFilePermission, filemode);
+ SCOPED_TRACE(trace);
+
+ static const char* fname = "apt-filefd-test.txt";
+ if (FileExists(fname) == true)
+ EXPECT_EQ(0, unlink(fname));
+ FileFd f;
umask(a_umask);
- equals(f.Open(fname, filemode, compressor), true);
- equals(f.IsOpen(), true);
- equals(f.Failed(), false);
- equals(umask(a_umask), a_umask);
+ EXPECT_TRUE(f.Open(fname, filemode, compressor));
+ EXPECT_TRUE(f.IsOpen());
+ EXPECT_FALSE(f.Failed());
+ EXPECT_EQ(umask(a_umask), a_umask);
- std::string test = "This is a test!";
- equals(f.Write(test.c_str(), test.size()), true);
- equals(f.IsOpen(), true);
- equals(f.Failed(), false);
+ std::string test = "This is a test!\n";
+ EXPECT_TRUE(f.Write(test.c_str(), test.size()));
+ EXPECT_TRUE(f.IsOpen());
+ EXPECT_FALSE(f.Failed());
f.Close();
- equals(f.IsOpen(), false);
- equals(f.Failed(), false);
+ EXPECT_FALSE(f.IsOpen());
+ EXPECT_FALSE(f.Failed());
+
+ EXPECT_TRUE(f.Open(fname, FileFd::ReadOnly, compressor));
+ EXPECT_TRUE(f.IsOpen());
+ EXPECT_FALSE(f.Failed());
+ EXPECT_FALSE(f.Eof());
+ EXPECT_NE(0, f.FileSize());
+ EXPECT_FALSE(f.Failed());
+ EXPECT_NE(0, f.ModificationTime());
+ EXPECT_FALSE(f.Failed());
- equals(f.Open(fname, FileFd::ReadOnly, compressor), true);
- equalsNot(f.FileSize(), 0);
- equals(f.IsOpen(), true);
- equals(f.Failed(), false);
+ // ensure the memory is as predictably messed up
+#define APT_INIT_READBACK \
+ char readback[20]; \
+ memset(readback, 'D', sizeof(readback)/sizeof(readback[0])); \
+ readback[19] = '\0';
+#define EXPECT_N_STR(expect, actual) \
+ EXPECT_EQ(0, strncmp(expect, actual, strlen(expect)));
- char readback[20];
{
+ APT_INIT_READBACK
char const * const expect = "This";
- equals(f.Read(readback, strlen(expect)), true);
- equals(f.Failed(), false);
- equals(f.Eof(), false);
- strequals(expect, readback);
- equals(strlen(expect), f.Tell());
+ EXPECT_TRUE(f.Read(readback, strlen(expect)));
+ EXPECT_FALSE(f.Failed());
+ EXPECT_FALSE(f.Eof());
+ EXPECT_N_STR(expect, readback);
+ EXPECT_EQ(strlen(expect), f.Tell());
}
{
- char const * const expect = "test!";
- equals(f.Skip((test.size() - f.Tell()) - strlen(expect)), true);
- equals(f.Read(readback, strlen(expect)), true);
- equals(f.Failed(), false);
- equals(f.Eof(), false);
- strequals(expect, readback);
- equals(test.size(), f.Tell());
+ APT_INIT_READBACK
+ char const * const expect = "test!\n";
+ EXPECT_TRUE(f.Skip((test.size() - f.Tell()) - strlen(expect)));
+ EXPECT_TRUE(f.Read(readback, strlen(expect)));
+ EXPECT_FALSE(f.Failed());
+ EXPECT_FALSE(f.Eof());
+ EXPECT_N_STR(expect, readback);
+ EXPECT_EQ(test.size(), f.Tell());
}
-
- equals(f.Seek(0), true);
- equals(f.Read(readback, 20, true), true);
- equals(f.Failed(), false);
- equals(f.Eof(), true);
- equals(test, readback);
- equals(test.size(), strlen(readback));
- equals(f.Size(), f.Tell());
-
- equals(f.Seek(0), true);
- f.ReadLine(readback, 20);
- equals(f.Failed(), false);
- equals(f.Eof(), true);
- equals(test, readback);
- equals(test.size(), strlen(readback));
- equals(f.Size(), f.Tell());
+ {
+ APT_INIT_READBACK
+ EXPECT_TRUE(f.Seek(0));
+ EXPECT_FALSE(f.Eof());
+ EXPECT_TRUE(f.Read(readback, 20, true));
+ EXPECT_FALSE(f.Failed());
+ EXPECT_TRUE(f.Eof());
+ EXPECT_N_STR(test.c_str(), readback);
+ EXPECT_EQ(f.Size(), f.Tell());
+ }
+ {
+ APT_INIT_READBACK
+ EXPECT_TRUE(f.Seek(0));
+ EXPECT_FALSE(f.Eof());
+ EXPECT_TRUE(f.Read(readback, test.size(), true));
+ EXPECT_FALSE(f.Failed());
+ EXPECT_FALSE(f.Eof());
+ EXPECT_N_STR(test.c_str(), readback);
+ EXPECT_EQ(f.Size(), f.Tell());
+ }
+ {
+ APT_INIT_READBACK
+ EXPECT_TRUE(f.Seek(0));
+ EXPECT_FALSE(f.Eof());
+ unsigned long long actual;
+ EXPECT_TRUE(f.Read(readback, 20, &actual));
+ EXPECT_FALSE(f.Failed());
+ EXPECT_TRUE(f.Eof());
+ EXPECT_EQ(test.size(), actual);
+ EXPECT_N_STR(test.c_str(), readback);
+ EXPECT_EQ(f.Size(), f.Tell());
+ }
+ {
+ APT_INIT_READBACK
+ EXPECT_TRUE(f.Seek(0));
+ EXPECT_FALSE(f.Eof());
+ f.ReadLine(readback, 20);
+ EXPECT_FALSE(f.Failed());
+ EXPECT_FALSE(f.Eof());
+ EXPECT_EQ(test, readback);
+ EXPECT_EQ(f.Size(), f.Tell());
+ }
+ {
+ APT_INIT_READBACK
+ EXPECT_TRUE(f.Seek(0));
+ EXPECT_FALSE(f.Eof());
+ char const * const expect = "This";
+ f.ReadLine(readback, strlen(expect) + 1);
+ EXPECT_FALSE(f.Failed());
+ EXPECT_FALSE(f.Eof());
+ EXPECT_N_STR(expect, readback);
+ EXPECT_EQ(strlen(expect), f.Tell());
+ }
+#undef APT_INIT_READBACK
f.Close();
- equals(f.IsOpen(), false);
- equals(f.Failed(), false);
+ EXPECT_FALSE(f.IsOpen());
+ EXPECT_FALSE(f.Failed());
// regression test for permission bug LP: #1304657
- if (stat(fname, &buf) < 0)
- {
- _error->Errno("stat", "failed to stat");
- return false;
- }
- unlink(fname);
- equals(buf.st_mode & 0777, ExpectedFilePermission);
- return true;
+ struct stat buf;
+ EXPECT_EQ(0, stat(fname, &buf));
+ EXPECT_EQ(0, unlink(fname));
+ EXPECT_EQ(ExpectedFilePermission, buf.st_mode & 0777);
}
-static bool TestFileFd(unsigned int const filemode)
+static void TestFileFd(unsigned int const filemode)
{
- std::vector<APT::Configuration::Compressor> const compressors = APT::Configuration::getCompressors();
+ std::vector<APT::Configuration::Compressor> compressors = APT::Configuration::getCompressors();
+
+ // testing the (un)compress via pipe, as the 'real' compressors are usually built in via libraries
+ compressors.push_back(APT::Configuration::Compressor("rev", ".reversed", "rev", NULL, NULL, 42));
+ //compressors.push_back(APT::Configuration::Compressor("cat", ".ident", "cat", NULL, NULL, 42));
+
for (std::vector<APT::Configuration::Compressor>::const_iterator c = compressors.begin(); c != compressors.end(); ++c)
{
if ((filemode & FileFd::ReadWrite) == FileFd::ReadWrite &&
(c->Name.empty() != true && c->Binary.empty() != true))
continue;
- if (TestFileFd(0002, 0664, filemode, *c) == false ||
- TestFileFd(0022, 0644, filemode, *c) == false ||
- TestFileFd(0077, 0600, filemode, *c) == false ||
- TestFileFd(0026, 0640, filemode, *c) == false)
- {
- _error->DumpErrors();
- return false;
- }
+ TestFileFd(0002, 0664, filemode, *c);
+ TestFileFd(0022, 0644, filemode, *c);
+ TestFileFd(0077, 0600, filemode, *c);
+ TestFileFd(0026, 0640, filemode, *c);
}
- return true;
}
-int main()
+TEST(FileUtlTest, FileFD)
{
- if (TestFileFd(FileFd::WriteOnly | FileFd::Create) == false ||
- TestFileFd(FileFd::WriteOnly | FileFd::Create | FileFd::Empty) == false ||
- TestFileFd(FileFd::WriteOnly | FileFd::Create | FileFd::Exclusive) == false ||
- TestFileFd(FileFd::WriteOnly | FileFd::Atomic) == false ||
- TestFileFd(FileFd::WriteOnly | FileFd::Create | FileFd::Atomic) == false ||
- // short-hands for ReadWrite with these modes
- TestFileFd(FileFd::WriteEmpty) == false ||
- TestFileFd(FileFd::WriteAny) == false ||
- TestFileFd(FileFd::WriteTemp) == false ||
- TestFileFd(FileFd::WriteAtomic) == false)
- {
- return 1;
- }
+ std::string const startdir = SafeGetCWD();
+ EXPECT_FALSE(startdir.empty());
+ std::string tempdir;
+ createTemporaryDirectory("filefd", tempdir);
+ EXPECT_EQ(0, chdir(tempdir.c_str()));
+
+ TestFileFd(FileFd::WriteOnly | FileFd::Create);
+ TestFileFd(FileFd::WriteOnly | FileFd::Create | FileFd::Empty);
+ TestFileFd(FileFd::WriteOnly | FileFd::Create | FileFd::Exclusive);
+ TestFileFd(FileFd::WriteOnly | FileFd::Atomic);
+ TestFileFd(FileFd::WriteOnly | FileFd::Create | FileFd::Atomic);
+ // short-hands for ReadWrite with these modes
+ TestFileFd(FileFd::WriteEmpty);
+ TestFileFd(FileFd::WriteAny);
+ TestFileFd(FileFd::WriteTemp);
+ TestFileFd(FileFd::WriteAtomic);
+ EXPECT_EQ(0, chdir(startdir.c_str()));
+ removeDirectory(tempdir);
+}
+TEST(FileUtlTest, Glob)
+{
std::vector<std::string> files;
// normal match
- files = Glob("*.lst");
- if (files.size() != 1)
- {
- _error->DumpErrors();
- return 1;
- }
+ files = Glob("*akefile");
+ EXPECT_EQ(1, files.size());
// not there
files = Glob("xxxyyyzzz");
- if (files.size() != 0 || _error->PendingError())
- {
- _error->DumpErrors();
- return 1;
- }
+ EXPECT_TRUE(files.empty());
+ EXPECT_FALSE(_error->PendingError());
// many matches (number is a bit random)
files = Glob("*.cc");
- if (files.size() < 10)
- {
- _error->DumpErrors();
- return 1;
- }
+ EXPECT_LT(10, files.size());
+}
+TEST(FileUtlTest, GetTempDir)
+{
+ char const * const envtmp = getenv("TMPDIR");
+ std::string old_tmpdir;
+ if (envtmp != NULL)
+ old_tmpdir = envtmp;
- // GetTempDir()
unsetenv("TMPDIR");
- equals(GetTempDir(), "/tmp");
+ EXPECT_EQ("/tmp", GetTempDir());
setenv("TMPDIR", "", 1);
- equals(GetTempDir(), "/tmp");
+ EXPECT_EQ("/tmp", GetTempDir());
setenv("TMPDIR", "/not-there-no-really-not", 1);
- equals(GetTempDir(), "/tmp");
+ EXPECT_EQ("/tmp", GetTempDir());
+ // here but not accessible for non-roots
setenv("TMPDIR", "/usr", 1);
- equals(GetTempDir(), "/usr");
+ EXPECT_EQ("/tmp", GetTempDir());
+
+ // files are no good for tmpdirs, too
+ setenv("TMPDIR", "/dev/null", 1);
+ EXPECT_EQ("/tmp", GetTempDir());
+
+ setenv("TMPDIR", "/var/tmp", 1);
+ EXPECT_EQ("/var/tmp", GetTempDir());
+
+ unsetenv("TMPDIR");
+ if (old_tmpdir.empty() == false)
+ setenv("TMPDIR", old_tmpdir.c_str(), 1);
+}
+TEST(FileUtlTest, Popen)
+{
+ FileFd Fd;
+ pid_t Child;
+ char buf[1024];
+ std::string s;
+ unsigned long long n = 0;
+ std::vector<std::string> OpenFds;
+
+ // count Fds to ensure we don't have a resource leak
+ if(FileExists("/proc/self/fd"))
+ OpenFds = Glob("/proc/self/fd/*");
+
+ // output something
+ const char* Args[10] = {"/bin/echo", "meepmeep", NULL};
+ bool res = Popen(Args, Fd, Child, FileFd::ReadOnly);
+ Fd.Read(buf, sizeof(buf)-1, &n);
+ buf[n] = 0;
+ EXPECT_NE(n, 0);
+ EXPECT_EQ(res, true);
+ EXPECT_STREQ(buf, "meepmeep\n");
+
+ // wait for the child to exit and cleanup
+ ExecWait(Child, "PopenRead");
+ Fd.Close();
+
+ // ensure that after a close all is good again
+ if(FileExists("/proc/self/fd"))
+ EXPECT_EQ(Glob("/proc/self/fd/*").size(), OpenFds.size());
+
+
+ // ReadWrite is not supported
+ res = Popen(Args, Fd, Child, FileFd::ReadWrite);
+ EXPECT_EQ(res, false);
+ _error->Discard();
+
+ // write something
+ Args[0] = "/bin/bash";
+ Args[1] = "-c";
+ Args[2] = "read";
+ Args[3] = NULL;
+ res = Popen(Args, Fd, Child, FileFd::WriteOnly);
+ s = "\n";
+ Fd.Write(s.c_str(), s.size());
+ Fd.Close();
+ ExecWait(Child, "PopenWrite");
+}
+TEST(FileUtlTest, flAbsPath)
+{
+ std::string cwd = SafeGetCWD();
+ int res = chdir("/bin/");
+ EXPECT_EQ(res, 0);
+ std::string p = flAbsPath("ls");
+ EXPECT_EQ(p, "/bin/ls");
- return 0;
+ res = chdir(cwd.c_str());
+ EXPECT_EQ(res, 0);
}
projects / apt.git / blobdiff