]> git.saurik.com Git - apt.git/blobdiff - test/libapt/fileutl_test.cc
CMake: Add unit tests
[apt.git] / test / libapt / fileutl_test.cc
index f3a3dd08ebbf5a22cd1cb9919b405f569eb86dcd..67bd850a123811149d72ab7c5b1c919fac1ffeea 100644 (file)
 
 #include <apt-pkg/error.h>
 #include <apt-pkg/fileutl.h>
 
 #include <apt-pkg/error.h>
 #include <apt-pkg/fileutl.h>
+#include <apt-pkg/strutl.h>
 #include <apt-pkg/aptconfiguration.h>
 #include <apt-pkg/aptconfiguration.h>
+#include <apt-pkg/configuration.h>
 
 
+#include <algorithm>
 #include <string>
 #include <vector>
 #include <stdlib.h>
 #include <string>
 #include <vector>
 #include <stdlib.h>
-#include <sys/stat.h>
 #include <string.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;
+   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)
    static const char* fname = "apt-filefd-test.txt";
    if (FileExists(fname) == true)
-      equals(unlink(fname), 0);
+      EXPECT_EQ(0, unlink(fname));
 
 
+   FileFd f;
    umask(a_umask);
    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!\n";
 
    std::string test = "This is a test!\n";
-   equals(f.Write(test.c_str(), test.size()), true);
-   equals(f.IsOpen(), true);
-   equals(f.Failed(), false);
+   EXPECT_TRUE(f.Write(test.c_str(), test.size()));
+   EXPECT_TRUE(f.IsOpen());
+   EXPECT_FALSE(f.Failed());
 
    f.Close();
 
    f.Close();
-   equals(f.IsOpen(), false);
-   equals(f.Failed(), false);
-
-   equals(f.Open(fname, FileFd::ReadOnly, compressor), true);
-   equals(f.IsOpen(), true);
-   equals(f.Failed(), false);
-   equals(f.Eof(), false);
-   equalsNot(f.FileSize(), 0);
-   equals(f.Failed(), false);
-   equalsNot(f.ModificationTime(), 0);
-   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());
 
    // ensure the memory is as predictably messed up
 
    // ensure the memory is as predictably messed up
-# define APT_INIT_READBACK \
+#define APT_INIT_READBACK \
    char readback[20]; \
    char readback[20]; \
-   memset(readback, 'D', sizeof(readback)/sizeof(readback[0])); \
+   memset(readback, 'D', sizeof(readback)*sizeof(readback[0])); \
    readback[19] = '\0';
    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";
-      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());
    }
    {
       APT_INIT_READBACK
       char const * const expect = "test!\n";
    }
    {
       APT_INIT_READBACK
       char const * const expect = "test!\n";
-      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());
+      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());
    }
    }
+   // Non-zero backwards seek
    {
       APT_INIT_READBACK
    {
       APT_INIT_READBACK
-      equals(f.Seek(0), true);
-      equals(f.Eof(), false);
-      equals(f.Read(readback, 20, true), true);
-      equals(f.Failed(), false);
-      equals(f.Eof(), true);
-      strequals(test.c_str(), readback);
-      equals(f.Size(), f.Tell());
+      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
    }
    {
       APT_INIT_READBACK
-      equals(f.Seek(0), true);
-      equals(f.Eof(), false);
-      equals(f.Read(readback, test.size(), true), true);
-      equals(f.Failed(), false);
-      equals(f.Eof(), false);
-      strequals(test.c_str(), readback);
-      equals(f.Size(), f.Tell());
+      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
    }
    {
       APT_INIT_READBACK
-      equals(f.Seek(0), true);
-      equals(f.Eof(), false);
+      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;
       unsigned long long actual;
-      equals(f.Read(readback, 20, &actual), true);
-      equals(f.Failed(), false);
-      equals(f.Eof(), true);
-      equals(test.size(), actual);
-      strequals(test.c_str(), readback);
-      equals(f.Size(), f.Tell());
+      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
    }
    {
       APT_INIT_READBACK
-      equals(f.Seek(0), true);
-      equals(f.Eof(), false);
+      EXPECT_TRUE(f.Seek(0));
+      EXPECT_FALSE(f.Eof());
       f.ReadLine(readback, 20);
       f.ReadLine(readback, 20);
-      equals(f.Failed(), false);
-      equals(f.Eof(), false);
-      equals(test, readback);
-      equals(f.Size(), f.Tell());
+      EXPECT_FALSE(f.Failed());
+      EXPECT_FALSE(f.Eof());
+      EXPECT_EQ(test, readback);
+      EXPECT_EQ(f.Size(), f.Tell());
    }
    {
       APT_INIT_READBACK
    }
    {
       APT_INIT_READBACK
-      equals(f.Seek(0), true);
-      equals(f.Eof(), false);
+      EXPECT_TRUE(f.Seek(0));
+      EXPECT_FALSE(f.Eof());
       char const * const expect = "This";
       f.ReadLine(readback, strlen(expect) + 1);
       char const * const expect = "This";
       f.ReadLine(readback, strlen(expect) + 1);
-      equals(f.Failed(), false);
-      equals(f.Eof(), false);
-      strequals(expect, readback);
-      equals(strlen(expect), f.Tell());
+      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();
    }
 #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
 
    // regression test for permission bug LP: #1304657
-   if (stat(fname, &buf) < 0)
-   {
-      _error->Errno("stat", "failed to stat");
-      return false;
-   }
-   equals(unlink(fname), 0);
-   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> 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)
+   auto const compressors = APT::Configuration::getCompressors();
+   EXPECT_EQ(7, compressors.size());
+   bool atLeastOneWasTested = false;
+   for (auto const &c: compressors)
    {
       if ((filemode & FileFd::ReadWrite) == FileFd::ReadWrite &&
    {
       if ((filemode & FileFd::ReadWrite) == FileFd::ReadWrite &&
-           (c->Name.empty() != true && c->Binary.empty() != true))
+           (c.Name.empty() != true && c.Binary.empty() != true))
         continue;
         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;
-      }
+      atLeastOneWasTested = true;
+      TestFileFd(0002, 0664, filemode, c);
+      TestFileFd(0022, 0644, filemode, c);
+      TestFileFd(0077, 0600, filemode, c);
+      TestFileFd(0026, 0640, filemode, c);
    }
    }
-   return true;
+   EXPECT_TRUE(atLeastOneWasTested);
 }
 
 }
 
-int main(int const argc, char const * const * const argv)
+TEST(FileUtlTest, FileFD)
 {
 {
-   std::string startdir;
-   if (argc > 1 && DirectoryExists(argv[1]) == true) {
-      startdir = SafeGetCWD();
-      equals(chdir(argv[1]), 0);
-   }
-   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;
-   }
-   if (startdir.empty() == false)
-      equals(chdir(startdir.c_str()), 0);
+   // testing the (un)compress via pipe, as the 'real' compressors are usually built in via libraries
+   _config->Set("APT::Compressor::rev::Name", "rev");
+   _config->Set("APT::Compressor::rev::Extension", ".reversed");
+   _config->Set("APT::Compressor::rev::Binary", "rev");
+   _config->Set("APT::Compressor::rev::Cost", 10);
+   auto const compressors = APT::Configuration::getCompressors(false);
+   EXPECT_EQ(7, compressors.size());
+   EXPECT_TRUE(std::any_of(compressors.begin(), compressors.end(), [](APT::Configuration::Compressor const &c) { return c.Name == "rev"; }));
+
+   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
    std::vector<std::string> files;
    // normal match
-   files = Glob("*.lst");
-   if (files.size() != 1)
-   {
-      _error->DumpErrors();
-      return 1;
-   }
+   files = Glob("*MakeLists.txt");
+   EXPECT_EQ(1, files.size());
 
    // not there
    files = Glob("xxxyyyzzz");
 
    // 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");
 
    // 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");
    unsetenv("TMPDIR");
-   equals(GetTempDir(), "/tmp");
+   EXPECT_EQ("/tmp", GetTempDir());
 
    setenv("TMPDIR", "", 1);
 
    setenv("TMPDIR", "", 1);
-   equals(GetTempDir(), "/tmp");
+   EXPECT_EQ("/tmp", GetTempDir());
 
    setenv("TMPDIR", "/not-there-no-really-not", 1);
 
    setenv("TMPDIR", "/not-there-no-really-not", 1);
-   equals(GetTempDir(), "/tmp");
+   EXPECT_EQ("/tmp", 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", "/usr", 1);
-   equals(GetTempDir(), "/usr");
+   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};
+   EXPECT_TRUE(Popen(Args, Fd, Child, FileFd::ReadOnly));
+   EXPECT_TRUE(Fd.Read(buf, sizeof(buf)-1, &n));
+   buf[n] = 0;
+   EXPECT_NE(n, 0);
+   EXPECT_STREQ(buf, "meepmeep\n");
+
+   // wait for the child to exit and cleanup
+   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());
+
+   // ReadWrite is not supported
+   _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;
+   EXPECT_TRUE(Popen(Args, Fd, Child, FileFd::WriteOnly));
+   s = "\n";
+   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();
+   int res = chdir("/etc/");
+   EXPECT_EQ(res, 0);
+   std::string p = flAbsPath("passwd");
+   EXPECT_EQ(p, "/etc/passwd");
+
+   res = chdir(cwd.c_str());
+   EXPECT_EQ(res, 0);
+}
+
+static void TestDevNullFileFd(unsigned int const filemode)
+{
+   SCOPED_TRACE(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);
+}
+constexpr char const * const TESTSTRING = "This is a test";
+static void TestFailingAtomicKeepsFile(char const * const label, std::string const &filename)
+{
+   SCOPED_TRACE(label);
+   EXPECT_TRUE(FileExists(filename));
+   FileFd fd;
+   EXPECT_TRUE(fd.Open(filename, FileFd::ReadOnly));
+   char buffer[50];
+   EXPECT_NE(nullptr, fd.ReadLine(buffer, sizeof(buffer)));
+   EXPECT_STREQ(TESTSTRING, buffer);
+}
+TEST(FileUtlTest, FailingAtomic)
+{
+   FileFd fd;
+   std::string filename;
+   createTemporaryFile("failingatomic", fd, &filename, TESTSTRING);
+   TestFailingAtomicKeepsFile("init", filename);
+
+   FileFd f;
+   EXPECT_TRUE(f.Open(filename, FileFd::ReadWrite | FileFd::Atomic));
+   f.EraseOnFailure();
+   EXPECT_FALSE(f.Failed());
+   EXPECT_TRUE(f.IsOpen());
+   TestFailingAtomicKeepsFile("before-fail", filename);
+   EXPECT_TRUE(f.Write("Bad file write", 10));
+   f.OpFail();
+   EXPECT_TRUE(f.Failed());
+   TestFailingAtomicKeepsFile("after-fail", filename);
+   EXPECT_TRUE(f.Close());
+   TestFailingAtomicKeepsFile("closed", filename);
 
 
-   return 0;
+   if (filename.empty() == false)
+      unlink(filename.c_str());
 }
 }