Implement <filesystem>

This patch implements the <filesystem> header and uses that
to provide <experimental/filesystem>.

Unlike other standard headers, the symbols needed for <filesystem>
have not yet been placed in libc++.so. Instead they live in the
new libc++fs.a library. Users of filesystem are required to link this
library. (Also note that libc++experimental no longer contains the
definition of <experimental/filesystem>, which now requires linking libc++fs).

The reason for keeping <filesystem> out of the dylib for now is that
it's still somewhat experimental, and the possibility of requiring an
ABI breaking change is very real. In the future the symbols will likely
be moved into the dylib, or the dylib will be made to link libc++fs automagically).

Note that moving the symbols out of libc++experimental may break user builds
until they update to -lc++fs. This should be OK, because the experimental
library provides no stability guarantees. However, I plan on looking into
ways we can force libc++experimental to automagically link libc++fs.

In order to use a single implementation and set of tests for <filesystem>, it
has been placed in a special `__fs` namespace. This namespace is inline in
C++17 onward, but not before that. As such implementation is available
in C++11 onward, but no filesystem namespace is present "directly", and
as such name conflicts shouldn't occur in C++11 or C++14.

llvm-svn: 338093

9 files changed, 839 insertions, 0 deletions

diff --git a/libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/copy.pass.cpp b/libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/copy.pass.cpp
new file mode 100644
index 00000000000..ac224ac7ae6
--- /dev/null
+++ b/libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/copy.pass.cpp
@@ -0,0 +1,59 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <filesystem>
+
+// class directory_iterator
+
+// directory_iterator(directory_iterator const&);
+
+#include "filesystem_include.hpp"
+#include <type_traits>
+#include <set>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace fs;
+
+TEST_SUITE(directory_iterator_copy_construct_tests)
+
+TEST_CASE(test_constructor_signature)
+{
+    using D = directory_iterator;
+    static_assert(std::is_copy_constructible<D>::value, "");
+}
+
+TEST_CASE(test_copy_end_iterator)
+{
+    const directory_iterator endIt;
+    directory_iterator it(endIt);
+    TEST_CHECK(it == endIt);
+}
+
+TEST_CASE(test_copy_valid_iterator)
+{
+    const path testDir = StaticEnv::Dir;
+    const directory_iterator endIt{};
+
+    const directory_iterator it(testDir);
+    TEST_REQUIRE(it != endIt);
+    const path entry = *it;
+
+    const directory_iterator it2(it);
+    TEST_REQUIRE(it2 == it);
+    TEST_CHECK(*it2 == entry);
+    TEST_CHECK(*it == entry);
+}
+
+TEST_SUITE_END()
diff --git a/libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/copy_assign.pass.cpp b/libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/copy_assign.pass.cpp
new file mode 100644
index 00000000000..3f08e4024de
--- /dev/null
+++ b/libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/copy_assign.pass.cpp
@@ -0,0 +1,98 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <filesystem>
+
+// class directory_iterator
+
+// directory_iterator& operator=(directory_iterator const&);
+
+#include "filesystem_include.hpp"
+#include <type_traits>
+#include <set>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace fs;
+
+TEST_SUITE(directory_iterator_copy_assign_tests)
+
+TEST_CASE(test_assignment_signature)
+{
+    using D = directory_iterator;
+    static_assert(std::is_copy_assignable<D>::value, "");
+}
+
+TEST_CASE(test_copy_to_end_iterator)
+{
+    const path testDir = StaticEnv::Dir;
+
+    const directory_iterator from(testDir);
+    TEST_REQUIRE(from != directory_iterator{});
+    const path entry = *from;
+
+    directory_iterator to{};
+    to = from;
+    TEST_REQUIRE(to == from);
+    TEST_CHECK(*to == entry);
+    TEST_CHECK(*from == entry);
+}
+
+
+TEST_CASE(test_copy_from_end_iterator)
+{
+    const path testDir = StaticEnv::Dir;
+
+    const directory_iterator from{};
+
+    directory_iterator to(testDir);
+    TEST_REQUIRE(to != directory_iterator{});
+
+    to = from;
+    TEST_REQUIRE(to == from);
+    TEST_CHECK(to == directory_iterator{});
+}
+
+TEST_CASE(test_copy_valid_iterator)
+{
+    const path testDir = StaticEnv::Dir;
+    const directory_iterator endIt{};
+
+    directory_iterator it_obj(testDir);
+    const directory_iterator& it = it_obj;
+    TEST_REQUIRE(it != endIt);
+    ++it_obj;
+    TEST_REQUIRE(it != endIt);
+    const path entry = *it;
+
+    directory_iterator it2(testDir);
+    TEST_REQUIRE(it2 != it);
+    const path entry2 = *it2;
+    TEST_CHECK(entry2 != entry);
+
+    it2 = it;
+    TEST_REQUIRE(it2 == it);
+    TEST_CHECK(*it2 == entry);
+}
+
+TEST_CASE(test_returns_reference_to_self)
+{
+    const directory_iterator it;
+    directory_iterator it2;
+    directory_iterator& ref = (it2 = it);
+    TEST_CHECK(&ref == &it2);
+}
+
+
+TEST_SUITE_END()
diff --git a/libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/ctor.pass.cpp b/libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/ctor.pass.cpp
new file mode 100644
index 00000000000..0a33544c547
--- /dev/null
+++ b/libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/ctor.pass.cpp
@@ -0,0 +1,254 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <filesystem>
+
+// class directory_iterator
+
+// explicit directory_iterator(const path& p);
+// directory_iterator(const path& p, directory_options options);
+// directory_iterator(const path& p, error_code& ec);
+// directory_iterator(const path& p, directory_options options, error_code& ec);
+
+#include "filesystem_include.hpp"
+#include <type_traits>
+#include <set>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace fs;
+
+TEST_SUITE(directory_iterator_constructor_tests)
+
+TEST_CASE(test_constructor_signatures)
+{
+    using D = directory_iterator;
+
+    // explicit directory_iterator(path const&);
+    static_assert(!std::is_convertible<path, D>::value, "");
+    static_assert(std::is_constructible<D, path>::value, "");
+    static_assert(!std::is_nothrow_constructible<D, path>::value, "");
+
+    // directory_iterator(path const&, error_code&)
+    static_assert(std::is_constructible<D, path,
+        std::error_code&>::value, "");
+    static_assert(!std::is_nothrow_constructible<D, path,
+        std::error_code&>::value, "");
+
+    // directory_iterator(path const&, directory_options);
+    static_assert(std::is_constructible<D, path, directory_options>::value, "");
+    static_assert(!std::is_nothrow_constructible<D, path, directory_options>::value, "");
+
+    // directory_iterator(path const&, directory_options, error_code&)
+    static_assert(std::is_constructible<D, path, directory_options,
+        std::error_code&>::value, "");
+    static_assert(!std::is_nothrow_constructible<D, path, directory_options,
+        std::error_code&>::value, "");
+
+}
+
+TEST_CASE(test_construction_from_bad_path)
+{
+    std::error_code ec;
+    directory_options opts = directory_options::none;
+    const directory_iterator endIt;
+
+    const path testPaths[] = { StaticEnv::DNE, StaticEnv::BadSymlink };
+    for (path const& testPath : testPaths)
+    {
+        {
+            directory_iterator it(testPath, ec);
+            TEST_CHECK(ec);
+            TEST_CHECK(it == endIt);
+        }
+        {
+            directory_iterator it(testPath, opts, ec);
+            TEST_CHECK(ec);
+            TEST_CHECK(it == endIt);
+        }
+        {
+            TEST_CHECK_THROW(filesystem_error, directory_iterator(testPath));
+            TEST_CHECK_THROW(filesystem_error, directory_iterator(testPath, opts));
+        }
+    }
+}
+
+TEST_CASE(access_denied_test_case)
+{
+    using namespace fs;
+    scoped_test_env env;
+    path const testDir = env.make_env_path("dir1");
+    path const testFile = testDir / "testFile";
+    env.create_dir(testDir);
+    env.create_file(testFile, 42);
+
+    // Test that we can iterator over the directory before changing the perms
+    {
+        directory_iterator it(testDir);
+        TEST_REQUIRE(it != directory_iterator{});
+    }
+    // Change the permissions so we can no longer iterate
+    permissions(testDir, perms::none);
+
+    // Check that the construction fails when skip_permissions_denied is
+    // not given.
+    {
+        std::error_code ec;
+        directory_iterator it(testDir, ec);
+        TEST_REQUIRE(ec);
+        TEST_CHECK(it == directory_iterator{});
+    }
+    // Check that construction does not report an error when
+    // 'skip_permissions_denied' is given.
+    {
+        std::error_code ec;
+        directory_iterator it(testDir, directory_options::skip_permission_denied, ec);
+        TEST_REQUIRE(!ec);
+        TEST_CHECK(it == directory_iterator{});
+    }
+}
+
+
+TEST_CASE(access_denied_to_file_test_case)
+{
+    using namespace fs;
+    scoped_test_env env;
+    path const testFile = env.make_env_path("file1");
+    env.create_file(testFile, 42);
+
+    // Change the permissions so we can no longer iterate
+    permissions(testFile, perms::none);
+
+    // Check that the construction fails when skip_permissions_denied is
+    // not given.
+    {
+        std::error_code ec;
+        directory_iterator it(testFile, ec);
+        TEST_REQUIRE(ec);
+        TEST_CHECK(it == directory_iterator{});
+    }
+    // Check that construction still fails when 'skip_permissions_denied' is given
+    // because we tried to open a file and not a directory.
+    {
+        std::error_code ec;
+        directory_iterator it(testFile, directory_options::skip_permission_denied, ec);
+        TEST_REQUIRE(ec);
+        TEST_CHECK(it == directory_iterator{});
+    }
+}
+
+TEST_CASE(test_open_on_empty_directory_equals_end)
+{
+    scoped_test_env env;
+    const path testDir = env.make_env_path("dir1");
+    env.create_dir(testDir);
+
+    const directory_iterator endIt;
+    {
+        std::error_code ec;
+        directory_iterator it(testDir, ec);
+        TEST_CHECK(!ec);
+        TEST_CHECK(it == endIt);
+    }
+    {
+        directory_iterator it(testDir);
+        TEST_CHECK(it == endIt);
+    }
+}
+
+TEST_CASE(test_open_on_directory_succeeds)
+{
+    const path testDir = StaticEnv::Dir;
+    std::set<path> dir_contents(std::begin(StaticEnv::DirIterationList),
+                                std::end(  StaticEnv::DirIterationList));
+    const directory_iterator endIt{};
+
+    {
+        std::error_code ec;
+        directory_iterator it(testDir, ec);
+        TEST_REQUIRE(!ec);
+        TEST_CHECK(it != endIt);
+        TEST_CHECK(dir_contents.count(*it));
+    }
+    {
+        directory_iterator it(testDir);
+        TEST_CHECK(it != endIt);
+        TEST_CHECK(dir_contents.count(*it));
+    }
+}
+
+TEST_CASE(test_open_on_file_fails)
+{
+    const path testFile = StaticEnv::File;
+    const directory_iterator endIt{};
+    {
+        std::error_code ec;
+        directory_iterator it(testFile, ec);
+        TEST_REQUIRE(ec);
+        TEST_CHECK(it == endIt);
+    }
+    {
+        TEST_CHECK_THROW(filesystem_error, directory_iterator(testFile));
+    }
+}
+
+TEST_CASE(test_open_on_empty_string)
+{
+    const path testPath = "";
+    const directory_iterator endIt{};
+
+    std::error_code ec;
+    directory_iterator it(testPath, ec);
+    TEST_CHECK(ec);
+    TEST_CHECK(it == endIt);
+}
+
+TEST_CASE(test_open_on_dot_dir)
+{
+    const path testPath = ".";
+
+    std::error_code ec;
+    directory_iterator it(testPath, ec);
+    TEST_CHECK(!ec);
+}
+
+TEST_CASE(test_open_on_symlink)
+{
+    const path symlinkToDir = StaticEnv::SymlinkToDir;
+    std::set<path> dir_contents;
+    for (path const& p : StaticEnv::DirIterationList) {
+        dir_contents.insert(p.filename());
+    }
+    const directory_iterator endIt{};
+
+    {
+        std::error_code ec;
+        directory_iterator it(symlinkToDir, ec);
+        TEST_REQUIRE(!ec);
+        TEST_CHECK(it != endIt);
+        path const& entry = *it;
+        TEST_CHECK(dir_contents.count(entry.filename()));
+    }
+    {
+        std::error_code ec;
+        directory_iterator it(symlinkToDir,
+                              directory_options::follow_directory_symlink, ec);
+        TEST_REQUIRE(!ec);
+        TEST_CHECK(it != endIt);
+        path const& entry = *it;
+        TEST_CHECK(dir_contents.count(entry.filename()));
+    }
+}
+
+TEST_SUITE_END()
diff --git a/libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/default_ctor.pass.cpp b/libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/default_ctor.pass.cpp
new file mode 100644
index 00000000000..21c4ed3b723
--- /dev/null
+++ b/libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/default_ctor.pass.cpp
@@ -0,0 +1,35 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <filesystem>
+
+// class directory_iterator
+
+// directory_iterator::directory_iterator() noexcept
+
+
+#include "filesystem_include.hpp"
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+
+int main() {
+    {
+        static_assert(std::is_nothrow_default_constructible<fs::directory_iterator>::value, "");
+    }
+    {
+        fs::directory_iterator d1;
+        const fs::directory_iterator d2;
+        assert(d1 == d2);
+    }
+}
diff --git a/libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/increment.pass.cpp b/libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/increment.pass.cpp
new file mode 100644
index 00000000000..7ec814b214e
--- /dev/null
+++ b/libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/increment.pass.cpp
@@ -0,0 +1,117 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <filesystem>
+
+// class directory_iterator
+
+// directory_iterator& operator++();
+// directory_iterator& increment(error_code& ec);
+
+#include "filesystem_include.hpp"
+#include <type_traits>
+#include <set>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+#include <iostream>
+
+using namespace fs;
+
+TEST_SUITE(directory_iterator_increment_tests)
+
+TEST_CASE(test_increment_signatures)
+{
+    using D = directory_iterator;
+    directory_iterator d; ((void)d);
+    std::error_code ec; ((void)ec);
+
+    ASSERT_SAME_TYPE(decltype(++d), directory_iterator&);
+    ASSERT_NOT_NOEXCEPT(++d);
+
+    ASSERT_SAME_TYPE(decltype(d.increment(ec)), directory_iterator&);
+    ASSERT_NOT_NOEXCEPT(d.increment(ec));
+}
+
+TEST_CASE(test_prefix_increment)
+{
+    const path testDir = StaticEnv::Dir;
+    const std::set<path> dir_contents(std::begin(StaticEnv::DirIterationList),
+                                      std::end(  StaticEnv::DirIterationList));
+    const directory_iterator endIt{};
+
+    std::error_code ec;
+    directory_iterator it(testDir, ec);
+    TEST_REQUIRE(!ec);
+
+    std::set<path> unseen_entries = dir_contents;
+    while (!unseen_entries.empty()) {
+        TEST_REQUIRE(it != endIt);
+        const path entry = *it;
+        TEST_REQUIRE(unseen_entries.erase(entry) == 1);
+        directory_iterator& it_ref = ++it;
+        TEST_CHECK(&it_ref == &it);
+    }
+
+    TEST_CHECK(it == endIt);
+}
+
+TEST_CASE(test_postfix_increment)
+{
+    const path testDir = StaticEnv::Dir;
+    const std::set<path> dir_contents(std::begin(StaticEnv::DirIterationList),
+                                      std::end(  StaticEnv::DirIterationList));
+    const directory_iterator endIt{};
+
+    std::error_code ec;
+    directory_iterator it(testDir, ec);
+    TEST_REQUIRE(!ec);
+
+    std::set<path> unseen_entries = dir_contents;
+    while (!unseen_entries.empty()) {
+        TEST_REQUIRE(it != endIt);
+        const path entry = *it;
+        TEST_REQUIRE(unseen_entries.erase(entry) == 1);
+        const path entry2 = *it++;
+        TEST_CHECK(entry2 == entry);
+    }
+
+    TEST_CHECK(it == endIt);
+}
+
+
+TEST_CASE(test_increment_method)
+{
+    const path testDir = StaticEnv::Dir;
+    const std::set<path> dir_contents(std::begin(StaticEnv::DirIterationList),
+                                      std::end(  StaticEnv::DirIterationList));
+    const directory_iterator endIt{};
+
+    std::error_code ec;
+    directory_iterator it(testDir, ec);
+    TEST_REQUIRE(!ec);
+
+    std::set<path> unseen_entries = dir_contents;
+    while (!unseen_entries.empty()) {
+        TEST_REQUIRE(it != endIt);
+        const path entry = *it;
+        TEST_REQUIRE(unseen_entries.erase(entry) == 1);
+        directory_iterator& it_ref = it.increment(ec);
+        TEST_REQUIRE(!ec);
+        TEST_CHECK(&it_ref == &it);
+    }
+
+    TEST_CHECK(it == endIt);
+}
+
+TEST_SUITE_END()
diff --git a/libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/move.pass.cpp b/libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/move.pass.cpp
new file mode 100644
index 00000000000..a2bf2ac9f2c
--- /dev/null
+++ b/libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/move.pass.cpp
@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <filesystem>
+
+// class directory_iterator
+
+// directory_iterator(directory_iterator&&) noexcept;
+
+#include "filesystem_include.hpp"
+#include <type_traits>
+#include <set>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace fs;
+
+TEST_SUITE(directory_iterator_move_construct_tests)
+
+TEST_CASE(test_constructor_signature)
+{
+    using D = directory_iterator;
+    static_assert(std::is_nothrow_move_constructible<D>::value, "");
+}
+
+TEST_CASE(test_move_end_iterator)
+{
+    const directory_iterator endIt;
+    directory_iterator endIt2{};
+
+    directory_iterator it(std::move(endIt2));
+    TEST_CHECK(it == endIt);
+    TEST_CHECK(endIt2 == endIt);
+}
+
+TEST_CASE(test_move_valid_iterator)
+{
+    const path testDir = StaticEnv::Dir;
+    const directory_iterator endIt{};
+
+    directory_iterator it(testDir);
+    TEST_REQUIRE(it != endIt);
+    const path entry = *it;
+
+    const directory_iterator it2(std::move(it));
+    TEST_CHECK(*it2 == entry);
+
+    TEST_CHECK(it == it2 || it == endIt);
+}
+
+TEST_SUITE_END()
diff --git a/libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/move_assign.pass.cpp b/libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/move_assign.pass.cpp
new file mode 100644
index 00000000000..1c722434402
--- /dev/null
+++ b/libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/move_assign.pass.cpp
@@ -0,0 +1,116 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <filesystem>
+
+// class directory_iterator
+
+// directory_iterator& operator=(directory_iterator const&);
+
+#include "filesystem_include.hpp"
+#include <type_traits>
+#include <set>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+// The filesystem specification explicitly allows for self-move on
+// the directory iterators. Turn off this warning so we can test it.
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wself-move"
+#endif
+
+using namespace fs;
+
+TEST_SUITE(directory_iterator_move_assign_tests)
+
+TEST_CASE(test_assignment_signature)
+{
+    using D = directory_iterator;
+    static_assert(std::is_nothrow_move_assignable<D>::value, "");
+}
+
+TEST_CASE(test_move_to_end_iterator)
+{
+    const path testDir = StaticEnv::Dir;
+
+    directory_iterator from(testDir);
+    TEST_REQUIRE(from != directory_iterator{});
+    const path entry = *from;
+
+    directory_iterator to{};
+    to = std::move(from);
+    TEST_REQUIRE(to != directory_iterator{});
+    TEST_CHECK(*to == entry);
+}
+
+
+TEST_CASE(test_move_from_end_iterator)
+{
+    const path testDir = StaticEnv::Dir;
+
+    directory_iterator from{};
+
+    directory_iterator to(testDir);
+    TEST_REQUIRE(to != from);
+
+    to = std::move(from);
+    TEST_REQUIRE(to == directory_iterator{});
+    TEST_REQUIRE(from == directory_iterator{});
+}
+
+TEST_CASE(test_move_valid_iterator)
+{
+    const path testDir = StaticEnv::Dir;
+    const directory_iterator endIt{};
+
+    directory_iterator it(testDir);
+    TEST_REQUIRE(it != endIt);
+    ++it;
+    TEST_REQUIRE(it != endIt);
+    const path entry = *it;
+
+    directory_iterator it2(testDir);
+    TEST_REQUIRE(it2 != it);
+    const path entry2 = *it2;
+    TEST_CHECK(entry2 != entry);
+
+    it2 = std::move(it);
+    TEST_REQUIRE(it2 != directory_iterator{});
+    TEST_CHECK(*it2 == entry);
+}
+
+TEST_CASE(test_returns_reference_to_self)
+{
+    directory_iterator it;
+    directory_iterator it2;
+    directory_iterator& ref = (it2 = it);
+    TEST_CHECK(&ref == &it2);
+}
+
+
+TEST_CASE(test_self_move)
+{
+    // Create two non-equal iterators that have exactly the same state.
+    directory_iterator it(StaticEnv::Dir);
+    directory_iterator it2(StaticEnv::Dir);
+    ++it; ++it2;
+    TEST_CHECK(it != it2);
+    TEST_CHECK(*it2 == *it);
+
+    it = std::move(it);
+    TEST_CHECK(*it2 == *it);
+}
+
+
+TEST_SUITE_END()
diff --git a/libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.nonmembers/begin_end.pass.cpp b/libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.nonmembers/begin_end.pass.cpp
new file mode 100644
index 00000000000..71e8e55ae03
--- /dev/null
+++ b/libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.nonmembers/begin_end.pass.cpp
@@ -0,0 +1,61 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <filesystem>
+
+// class directory_iterator
+
+// directory_iterator begin(directory_iterator iter) noexcept;
+// directory_iterator end(directory_iterator iter) noexcept;
+
+#include "filesystem_include.hpp"
+#include <type_traits>
+#include <set>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+#include <iostream>
+
+using namespace fs;
+
+TEST_SUITE(directory_iterator_begin_end_tests)
+
+TEST_CASE(test_function_signatures)
+{
+    using D = directory_iterator;
+    directory_iterator d; ((void)d);
+
+    ASSERT_SAME_TYPE(decltype(begin(d)), directory_iterator);
+    ASSERT_NOEXCEPT(begin(std::move(d)));
+
+    ASSERT_SAME_TYPE(decltype(end(d)), directory_iterator);
+    ASSERT_NOEXCEPT(end(std::move(d)));
+}
+
+TEST_CASE(test_ranged_for_loop)
+{
+    const path testDir = StaticEnv::Dir;
+    std::set<path> dir_contents(std::begin(StaticEnv::DirIterationList),
+                                      std::end(  StaticEnv::DirIterationList));
+
+    std::error_code ec;
+    directory_iterator it(testDir, ec);
+    TEST_REQUIRE(!ec);
+
+    for (auto& elem : it) {
+        TEST_CHECK(dir_contents.erase(elem) == 1);
+    }
+    TEST_CHECK(dir_contents.empty());
+}
+
+TEST_SUITE_END()
diff --git a/libcxx/test/std/input.output/filesystems/class.directory_iterator/types.pass.cpp b/libcxx/test/std/input.output/filesystems/class.directory_iterator/types.pass.cpp
new file mode 100644
index 00000000000..4619083e8c3
--- /dev/null
+++ b/libcxx/test/std/input.output/filesystems/class.directory_iterator/types.pass.cpp
@@ -0,0 +1,37 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <filesystem>
+
+// class directory_iterator
+
+// typedef ... value_type;
+// typedef ... difference_type;
+// typedef ... pointer;
+// typedef ... reference;
+// typedef ... iterator_category
+
+#include "filesystem_include.hpp"
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+
+int main() {
+    using namespace fs;
+    using D = directory_iterator;
+    ASSERT_SAME_TYPE(D::value_type, directory_entry);
+    ASSERT_SAME_TYPE(D::difference_type, std::ptrdiff_t);
+    ASSERT_SAME_TYPE(D::pointer, const directory_entry*);
+    ASSERT_SAME_TYPE(D::reference, const directory_entry&);
+    ASSERT_SAME_TYPE(D::iterator_category, std::input_iterator_tag);
+}