Support/PathV2: Remove the error_code return type from all functions in the path

[oota-llvm.git] / unittests / Support / Path.cpp

diff --git a/unittests/Support/Path.cpp b/unittests/Support/Path.cpp
index 5ab74e14f70f28677d2bb520332479481595d1a8..016a7cd5873f9df25905325a5c7d838d2de11b29 100644 (file)
--- a/unittests/Support/Path.cpp
+++ b/unittests/Support/Path.cpp
@@ -7,11 +7,14 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/Support/FileSystem.h"
 #include "llvm/Support/PathV2.h"
+#include "llvm/Support/ErrorHandling.h"
 
 #include "gtest/gtest.h"
 
 using namespace llvm;
+using namespace llvm::sys;
 
 namespace {
 
@@ -62,15 +65,14 @@ TEST(Support, Path) {
                                                   e = paths.end();
                                                   i != e;
                                                   ++i) {
-    outs() << *i << " =>\n    Iteration: [";
     for (sys::path::const_iterator ci = sys::path::begin(*i),
                                    ce = sys::path::end(*i);
                                    ci != ce;
                                    ++ci) {
-      outs() << *ci << ',';
+      ASSERT_FALSE(ci->empty());
     }
-    outs() << "]\n";
 
+#if 0 // Valgrind is whining about this.
     outs() << "    Reverse Iteration: [";
     for (sys::path::reverse_iterator ci = sys::path::rbegin(*i),
                                      ce = sys::path::rend(*i);
@@ -79,33 +81,106 @@ TEST(Support, Path) {
       outs() << *ci << ',';
     }
     outs() << "]\n";
+#endif
 
-    StringRef res;
-    SmallString<16> temp_store;
-    if (error_code ec = sys::path::root_path(*i, res))
-      ASSERT_FALSE(ec.message().c_str());
-    outs() << "    root_path: " << res << '\n';
-    if (error_code ec = sys::path::root_name(*i, res))
-      ASSERT_FALSE(ec.message().c_str());
-    outs() << "    root_name: " << res << '\n';
-    if (error_code ec = sys::path::root_directory(*i, res))
-      ASSERT_FALSE(ec.message().c_str());
-    outs() << "    root_directory: " << res << '\n';
-    if (error_code ec = sys::path::parent_path(*i, res))
-      ASSERT_FALSE(ec.message().c_str());
-    outs() << "    parent_path: " << res << '\n';
+    bool      bres;
+    StringRef sfres;
+    path::has_root_path(*i, bres);
+    path::root_path(*i, sfres);
+    path::has_root_name(*i, bres);
+    path::root_name(*i, sfres);
+    path::has_root_directory(*i, bres);
+    path::root_directory(*i, sfres);
+    path::has_parent_path(*i, bres);
+    path::parent_path(*i, sfres);
+    path::has_filename(*i, bres);
+    path::filename(*i, sfres);
+    path::has_stem(*i, bres);
+    path::stem(*i, sfres);
+    path::has_extension(*i, bres);
+    path::extension(*i, sfres);
+    path::is_absolute(*i, bres);
+    path::is_relative(*i, bres);
 
+    SmallString<16> temp_store;
+    temp_store = *i;
+    ASSERT_FALSE(fs::make_absolute(temp_store));
     temp_store = *i;
-    if (error_code ec = sys::path::make_absolute(temp_store))
-      ASSERT_FALSE(ec.message().c_str());
-    outs() << "    make_absolute: " << temp_store << '\n';
+    path::remove_filename(temp_store);
+
     temp_store = *i;
-    if (error_code ec = sys::path::remove_filename(temp_store))
-      ASSERT_FALSE(ec.message().c_str());
-    outs() << "    remove_filename: " << temp_store << '\n';
+    path::replace_extension(temp_store, "ext");
+    StringRef filename(temp_store.begin(), temp_store.size()), stem, ext;
+    path::stem(filename, stem);
+    path::extension(filename, ext);
+    EXPECT_EQ(*(--sys::path::end(filename)), (stem + ext).str());
+
+    path::native(*i, temp_store);
 
     outs().flush();
   }
+
+  // Create a temp file.
+  int FileDescriptor;
+  SmallString<64> TempPath;
+  ASSERT_FALSE(fs::unique_file("%%-%%-%%-%%.temp", FileDescriptor, TempPath));
+
+  // Make sure it exists.
+  bool TempFileExists;
+  ASSERT_FALSE(sys::fs::exists(Twine(TempPath), TempFileExists));
+  EXPECT_TRUE(TempFileExists);
+
+  // Create another temp tile.
+  int FD2;
+  SmallString<64> TempPath2;
+  ASSERT_FALSE(fs::unique_file("%%-%%-%%-%%.temp", FD2, TempPath2));
+  ASSERT_NE(TempPath.str(), TempPath2.str());
+
+  // Try to copy the first to the second.
+  EXPECT_EQ(fs::copy_file(Twine(TempPath), Twine(TempPath2)), errc::file_exists);
+
+  ::close(FD2);
+  // Try again with the proper options.
+  ASSERT_FALSE(fs::copy_file(Twine(TempPath), Twine(TempPath2),
+                             fs::copy_option::overwrite_if_exists));
+  // Remove Temp2.
+  ASSERT_FALSE(fs::remove(Twine(TempPath2), TempFileExists));
+  EXPECT_TRUE(TempFileExists);
+
+  // Make sure Temp2 doesn't exist.
+  ASSERT_FALSE(fs::exists(Twine(TempPath2), TempFileExists));
+  EXPECT_FALSE(TempFileExists);
+
+  // Create a hard link to Temp1.
+  ASSERT_FALSE(fs::create_hard_link(Twine(TempPath), Twine(TempPath2)));
+  bool equal;
+  ASSERT_FALSE(fs::equivalent(Twine(TempPath), Twine(TempPath2), equal));
+  EXPECT_TRUE(equal);
+
+  // Remove Temp1.
+  ::close(FileDescriptor);
+  ASSERT_FALSE(fs::remove(Twine(TempPath), TempFileExists));
+  EXPECT_TRUE(TempFileExists);
+
+  // Remove the hard link.
+  ASSERT_FALSE(fs::remove(Twine(TempPath2), TempFileExists));
+  EXPECT_TRUE(TempFileExists);
+
+  // Make sure Temp1 doesn't exist.
+  ASSERT_FALSE(fs::exists(Twine(TempPath), TempFileExists));
+  EXPECT_FALSE(TempFileExists);
+
+  // I've yet to do directory iteration on Unix.
+#ifdef LLVM_ON_WIN32
+  error_code ec;
+  for (fs::directory_iterator i(".", ec), e; i != e; i.increment(ec)) {
+    if (ec) {
+      errs() << ec.message() << '\n';
+      errs().flush();
+      report_fatal_error("Directory iteration failed!");
+    }
+  }
+#endif
 }
 
 } // anonymous namespace