pass versioned provides to external solvers in EDSP

[apt.git] / test / libapt / fileutl_test.cc

diff --git a/test/libapt/fileutl_test.cc b/test/libapt/fileutl_test.cc
index cdf7ea479a75bf276ce3f58237c4fa859d464b30..607c4a195bbae2361267d96e11b1a32c6864c67e 100644 (file)
--- a/test/libapt/fileutl_test.cc
+++ b/test/libapt/fileutl_test.cc
@@ -53,11 +53,16 @@ static void TestFileFd(mode_t const a_umask, mode_t const ExpectedFilePermission
    // ensure the memory is as predictably messed up
 #define APT_INIT_READBACK \
    char readback[20]; \
    // ensure the memory is as predictably messed up
 #define APT_INIT_READBACK \
    char readback[20]; \

-   memset(readback, 'D', sizeof(readback)/sizeof(readback[0])); \
+   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)));
    readback[19] = '\0';
 #define EXPECT_N_STR(expect, actual) \
    EXPECT_EQ(0, strncmp(expect, actual, strlen(expect)));

-
+   {
+      APT_INIT_READBACK
+      char const * const expect = "DDDDDDDDDDDDDDDDDDD";
+      EXPECT_STREQ(expect,readback);
+      EXPECT_N_STR(expect, readback);
+   }

    {
       APT_INIT_READBACK
       char const * const expect = "This";
    {
       APT_INIT_READBACK
       char const * const expect = "This";


@@ -77,6 +82,18 @@ static void TestFileFd(mode_t const a_umask, mode_t const ExpectedFilePermission
       EXPECT_N_STR(expect, readback);
       EXPECT_EQ(test.size(), f.Tell());
    }
       EXPECT_N_STR(expect, readback);
       EXPECT_EQ(test.size(), f.Tell());
    }

+   // Non-zero backwards seek
+   {
+      APT_INIT_READBACK
+      char const * const expect = "is";
+      EXPECT_EQ(test.size(), f.Tell());
+      EXPECT_TRUE(f.Seek(5));
+      EXPECT_TRUE(f.Read(readback, strlen(expect)));
+      EXPECT_FALSE(f.Failed());
+      EXPECT_FALSE(f.Eof());
+      EXPECT_N_STR(expect, readback);
+      EXPECT_EQ(7, f.Tell());
+   }

    {
       APT_INIT_READBACK
       EXPECT_TRUE(f.Seek(0));
    {
       APT_INIT_READBACK
       EXPECT_TRUE(f.Seek(0));


@@ -217,8 +234,20 @@ TEST(FileUtlTest, GetTempDir)
    setenv("TMPDIR", "/not-there-no-really-not", 1);
    EXPECT_EQ("/tmp", GetTempDir());
 
    setenv("TMPDIR", "/not-there-no-really-not", 1);
    EXPECT_EQ("/tmp", GetTempDir());
 

-   setenv("TMPDIR", "/usr", 1);
-   EXPECT_EQ("/usr", GetTempDir());
+   // root can access everything, so /usr will be accepted
+   if (geteuid() != 0)
+   {
+       // here but not accessible for non-roots
+       setenv("TMPDIR", "/usr", 1);
+       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)
 
    unsetenv("TMPDIR");
    if (old_tmpdir.empty() == false)


@@ -239,46 +268,79 @@ TEST(FileUtlTest, Popen)
 
    // output something
    const char* Args[10] = {"/bin/echo", "meepmeep", NULL};
 
    // 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);
+   EXPECT_TRUE(Popen(Args, Fd, Child, FileFd::ReadOnly));
+   EXPECT_TRUE(Fd.Read(buf, sizeof(buf)-1, &n));

    buf[n] = 0;
    EXPECT_NE(n, 0);
    buf[n] = 0;
    EXPECT_NE(n, 0);

-   EXPECT_EQ(res, true);

    EXPECT_STREQ(buf, "meepmeep\n");
 
    // wait for the child to exit and cleanup
    EXPECT_STREQ(buf, "meepmeep\n");
 
    // wait for the child to exit and cleanup

-   ExecWait(Child, "PopenRead");
-   Fd.Close();
+   EXPECT_TRUE(ExecWait(Child, "PopenRead"));
+   EXPECT_TRUE(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());
 
 
    // 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
    // ReadWrite is not supported

-   res = Popen(Args, Fd, Child, FileFd::ReadWrite);
-   EXPECT_EQ(res, false);
-   _error->Discard();
+   _error->PushToStack();
+   EXPECT_FALSE(Popen(Args, Fd, Child, FileFd::ReadWrite));
+   EXPECT_FALSE(Fd.IsOpen());
+   EXPECT_FALSE(Fd.Failed());
+   EXPECT_TRUE(_error->PendingError());
+   _error->RevertToStack();

 
    // write something
    Args[0] = "/bin/bash";
    Args[1] = "-c";
    Args[2] = "read";
    Args[3] = NULL;
 
    // write something
    Args[0] = "/bin/bash";
    Args[1] = "-c";
    Args[2] = "read";
    Args[3] = NULL;

-   res = Popen(Args, Fd, Child, FileFd::WriteOnly);
+   EXPECT_TRUE(Popen(Args, Fd, Child, FileFd::WriteOnly));

    s = "\n";
    s = "\n";

-   Fd.Write(s.c_str(), s.size());
-   Fd.Close();
-   ExecWait(Child, "PopenWrite");
+   EXPECT_TRUE(Fd.Write(s.c_str(), s.length()));
+   EXPECT_TRUE(Fd.Close());
+   EXPECT_FALSE(Fd.IsOpen());
+   EXPECT_FALSE(Fd.Failed());
+   EXPECT_TRUE(ExecWait(Child, "PopenWrite"));

 }
 TEST(FileUtlTest, flAbsPath)
 {
    std::string cwd = SafeGetCWD();
 }
 TEST(FileUtlTest, flAbsPath)
 {
    std::string cwd = SafeGetCWD();

-   int res = chdir("/bin/");
+   int res = chdir("/etc/");

    EXPECT_EQ(res, 0);
    EXPECT_EQ(res, 0);

-   std::string p = flAbsPath("ls");
-   EXPECT_EQ(p, "/bin/ls");
+   std::string p = flAbsPath("passwd");
+   EXPECT_EQ(p, "/etc/passwd");

 
    res = chdir(cwd.c_str());
    EXPECT_EQ(res, 0);
 }
 
    res = chdir(cwd.c_str());
    EXPECT_EQ(res, 0);
 }

+
+static void TestDevNullFileFd(unsigned int const filemode)
+{
+   FileFd f("/dev/null", filemode);
+   EXPECT_FALSE(f.Failed());
+   EXPECT_TRUE(f.IsOpen());
+   EXPECT_TRUE(f.IsOpen());
+
+   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();
+   EXPECT_FALSE(f.IsOpen());
+   EXPECT_FALSE(f.Failed());
+}
+TEST(FileUtlTest, WorkingWithDevNull)
+{
+   TestDevNullFileFd(FileFd::WriteOnly | FileFd::Create);
+   TestDevNullFileFd(FileFd::WriteOnly | FileFd::Create | FileFd::Empty);
+   TestDevNullFileFd(FileFd::WriteOnly | FileFd::Create | FileFd::Exclusive);
+   TestDevNullFileFd(FileFd::WriteOnly | FileFd::Atomic);
+   TestDevNullFileFd(FileFd::WriteOnly | FileFd::Create | FileFd::Atomic);
+   // short-hands for ReadWrite with these modes
+   TestDevNullFileFd(FileFd::WriteEmpty);
+   TestDevNullFileFd(FileFd::WriteAny);
+   TestDevNullFileFd(FileFd::WriteTemp);
+   TestDevNullFileFd(FileFd::WriteAtomic);
+}