Vendor import of libc++ release_39 branch r276489:vendor/libc++/libc++-release_39-r276489

https://llvm.org/svn/llvm-project/libcxx/branches/release_39@276489

2421 files changed, 50626 insertions, 13676 deletions

diff --git a/.arcconfig b/.arcconfig
index 6d07e827fcb8..c96fbc1b4e6c 100644
--- a/.arcconfig
+++ b/.arcconfig
@@ -1,4 +1,4 @@
 {
   "project_id" : "libcxx",
-  "conduit_uri" : "http://reviews.llvm.org/"
+  "conduit_uri" : "https://reviews.llvm.org/"
 }
diff --git a/CMakeLists.txt b/CMakeLists.txt
index e6c96f64711b..d618e8358cae 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -3,7 +3,7 @@
 #===============================================================================
 # Setup Project
 #===============================================================================
-cmake_minimum_required(VERSION 2.8)
+cmake_minimum_required(VERSION 3.4.3)
 
 if(POLICY CMP0042)
   cmake_policy(SET CMP0042 NEW) # Set MACOSX_RPATH=YES by default
@@ -12,13 +12,6 @@ if(POLICY CMP0022)
   cmake_policy(SET CMP0022 NEW) # Required when interacting with LLVM and Clang
 endif()
 
-project(libcxx CXX C)
-
-set(PACKAGE_NAME libcxx)
-set(PACKAGE_VERSION trunk-svn)
-set(PACKAGE_STRING "${PACKAGE_NAME} ${PACKAGE_VERSION}")
-set(PACKAGE_BUGREPORT "llvm-bugs@lists.llvm.org")
-
 # Add path for custom modules
 set(CMAKE_MODULE_PATH
   "${CMAKE_CURRENT_SOURCE_DIR}/cmake"
@@ -26,15 +19,18 @@ set(CMAKE_MODULE_PATH
   ${CMAKE_MODULE_PATH}
   )
 
-# Require out of source build.
-include(MacroEnsureOutOfSourceBuild)
-MACRO_ENSURE_OUT_OF_SOURCE_BUILD(
- "${PROJECT_NAME} requires an out of source build. Please create a separate
- build directory and run 'cmake /path/to/${PROJECT_NAME} [options]' there."
- )
-
 # Find the LLVM sources and simulate LLVM CMake options.
 include(HandleOutOfTreeLLVM)
+
+if (LIBCXX_BUILT_STANDALONE)
+  project(libcxx CXX C)
+
+  set(PACKAGE_NAME libcxx)
+  set(PACKAGE_VERSION trunk-svn)
+  set(PACKAGE_STRING "${PACKAGE_NAME} ${PACKAGE_VERSION}")
+  set(PACKAGE_BUGREPORT "llvm-bugs@lists.llvm.org")
+endif ()
+
 if (LIBCXX_BUILT_STANDALONE AND NOT LLVM_FOUND)
   message(WARNING "UNSUPPORTED LIBCXX CONFIGURATION DETECTED: "
                   "llvm-config not found and LLVM_PATH not defined.\n"
@@ -42,6 +38,13 @@ if (LIBCXX_BUILT_STANDALONE AND NOT LLVM_FOUND)
                   "or -DLLVM_PATH=path/to/llvm-source-root.")
 endif()
 
+# Require out of source build.
+include(MacroEnsureOutOfSourceBuild)
+MACRO_ENSURE_OUT_OF_SOURCE_BUILD(
+ "${PROJECT_NAME} requires an out of source build. Please create a separate
+ build directory and run 'cmake /path/to/${PROJECT_NAME} [options]' there."
+ )
+
 #===============================================================================
 # Setup CMake Options
 #===============================================================================
@@ -49,7 +52,9 @@ endif()
 # Basic options ---------------------------------------------------------------
 option(LIBCXX_ENABLE_ASSERTIONS "Enable assertions independent of build mode." ON)
 option(LIBCXX_ENABLE_SHARED "Build libc++ as a shared library." ON)
-
+option(LIBCXX_ENABLE_EXPERIMENTAL_LIBRARY "Build libc++experimental.a" ON)
+option(LIBCXX_ENABLE_FILESYSTEM
+        "Build filesystem as part of libc++experimental.a" ${LIBCXX_ENABLE_EXPERIMENTAL_LIBRARY})
 option(LIBCXX_INCLUDE_TESTS "Build the libc++ tests." ${LLVM_INCLUDE_TESTS})
 option(LIBCXX_INCLUDE_DOCS "Build the libc++ documentation." ${LLVM_INCLUDE_DOCS})
 set(LIBCXX_LIBDIR_SUFFIX "${LLVM_LIBDIR_SUFFIX}" CACHE STRING
@@ -57,6 +62,7 @@ set(LIBCXX_LIBDIR_SUFFIX "${LLVM_LIBDIR_SUFFIX}" CACHE STRING
 option(LIBCXX_INSTALL_HEADERS "Install the libc++ headers." ON)
 option(LIBCXX_INSTALL_LIBRARY "Install the libc++ library." ON)
 option(LIBCXX_INSTALL_SUPPORT_HEADERS "Install libc++ support headers." ON)
+option(LIBCXX_INSTALL_EXPERIMENTAL_LIBRARY "Install libc++experimental.a" OFF)
 set(LIBCXX_ABI_VERSION 1 CACHE STRING "ABI version of libc++.")
 option(LIBCXX_ABI_UNSTABLE "Unstable ABI of libc++." OFF)
 
@@ -92,7 +98,8 @@ option(LIBCXX_ENABLE_STATIC_ABI_LIBRARY "Statically link the ABI library" OFF)
 set(ENABLE_LINKER_SCRIPT_DEFAULT_VALUE OFF)
 if (LLVM_HAVE_LINK_VERSION_SCRIPT AND NOT LIBCXX_ENABLE_STATIC_ABI_LIBRARY
       AND NOT LIBCXX_CXX_ABI_LIBNAME STREQUAL "none"
-      AND PYTHONINTERP_FOUND)
+      AND PYTHONINTERP_FOUND
+      AND LIBCXX_ENABLE_SHARED)
     set(ENABLE_LINKER_SCRIPT_DEFAULT_VALUE ON)
 endif()
 
@@ -121,12 +128,14 @@ option(LIBCXX_ENABLE_MONOTONIC_CLOCK
   "Build libc++ with support for a monotonic clock.
    This option may only be set to OFF when LIBCXX_ENABLE_THREADS=OFF." ON)
 option(LIBCXX_HAS_MUSL_LIBC "Build libc++ with support for the Musl C library" OFF)
+option(LIBCXX_HAS_PTHREAD_API "Ignore auto-detection and force use of pthread API" OFF)
 
 # Misc options ----------------------------------------------------------------
 # FIXME: Turn -pedantic back ON. It is currently off because it warns
 # about #include_next which is used everywhere.
 option(LIBCXX_ENABLE_PEDANTIC "Compile with pedantic enabled." OFF)
 option(LIBCXX_ENABLE_WERROR "Fail and stop if a warning is triggered." OFF)
+option(LIBCXX_DISABLE_MACRO_CONFLICT_WARNINGS "Disable #warnings about conflicting macros." OFF)
 
 option(LIBCXX_GENERATE_COVERAGE "Enable generating code coverage." OFF)
 set(LIBCXX_COVERAGE_LIBRARY "" CACHE STRING
@@ -160,6 +169,11 @@ option(LIBCXX_CONFIGURE_IDE "Configure libcxx for use within an IDE"
 # Check option configurations
 #===============================================================================
 
+if (LIBCXX_ENABLE_FILESYSTEM AND NOT LIBCXX_ENABLE_EXPERIMENTAL_LIBRARY)
+  message(FATAL_ERROR
+    "LIBCXX_ENABLE_FILESYSTEM cannot be turned on when LIBCXX_ENABLE_EXPERIMENTAL_LIBRARY=OFF")
+endif()
+
 # Ensure LIBCXX_ENABLE_MONOTONIC_CLOCK is set to ON only when
 # LIBCXX_ENABLE_THREADS is on.
 if(LIBCXX_ENABLE_THREADS AND NOT LIBCXX_ENABLE_MONOTONIC_CLOCK)
@@ -167,6 +181,11 @@ if(LIBCXX_ENABLE_THREADS AND NOT LIBCXX_ENABLE_MONOTONIC_CLOCK)
                       " when LIBCXX_ENABLE_THREADS is also set to OFF.")
 endif()
 
+if(LIBCXX_HAS_PTHREAD_API AND NOT LIBCXX_ENABLE_THREADS)
+  message(FATAL_ERROR "LIBCXX_HAS_PTHREAD_API can only be set to ON"
+                      " when LIBCXX_ENABLE_THREADS is also set to ON.")
+endif()
+
 # Ensure LLVM_USE_SANITIZER is not specified when LIBCXX_GENERATE_COVERAGE
 # is ON.
 if (LLVM_USE_SANITIZER AND LIBCXX_GENERATE_COVERAGE)
@@ -199,6 +218,9 @@ if (LIBCXX_ENABLE_ABI_LINKER_SCRIPT)
     if (NOT PYTHONINTERP_FOUND)
       message(FATAL_ERROR "LIBCXX_ENABLE_ABI_LINKER_SCRIPT requires python but it was not found.")
     endif()
+    if (NOT LIBCXX_ENABLE_SHARED)
+      message(FATAL_ERROR "LIBCXX_ENABLE_ABI_LINKER_SCRIPT is only available for shared library builds.")
+    endif()
 endif()
 
 if (LIBCXX_ENABLE_STATIC_ABI_LIBRARY AND LIBCXX_ENABLE_ABI_LINKER_SCRIPT)
@@ -233,6 +255,18 @@ set(LIBCXX_COMPILE_FLAGS "")
 set(LIBCXX_LINK_FLAGS "")
 set(LIBCXX_LIBRARIES "")
 
+# Include macros for adding and removing libc++ flags.
+include(HandleLibcxxFlags)
+
+# Target flags ================================================================
+# These flags get added to CMAKE_CXX_FLAGS and CMAKE_C_FLAGS so that
+# 'config-ix' use them during feature checks. It also adds them to both
+# 'LIBCXX_COMPILE_FLAGS' and 'LIBCXX_LINK_FLAGS'
+add_target_flags_if(LIBCXX_BUILD_32_BITS "-m32")
+add_target_flags_if(LIBCXX_TARGET_TRIPLE "-target ${LIBCXX_TARGET_TRIPLE}")
+add_target_flags_if(LIBCXX_SYSROOT "--sysroot=${LIBCXX_SYSROOT}")
+add_target_flags_if(LIBCXX_GCC_TOOLCHAIN "-gcc-toolchain ${LIBCXX_GCC_TOOLCHAIN}")
+
 # Configure compiler.
 include(config-ix)
 
@@ -248,10 +282,7 @@ string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)
 # Setup Compiler Flags
 #===============================================================================
 
-include(HandleLibCXXABI) # Steup the ABI library flags
-
-# Include macros for adding and removing libc++ flags.
-include(HandleLibcxxFlags)
+include(HandleLibCXXABI) # Setup the ABI library flags
 
 # Remove flags that may have snuck in.
 remove_flags(-DNDEBUG -UNDEBUG -D_DEBUG
@@ -274,17 +305,13 @@ endif()
 # headers
 add_compile_flags_if_supported(-nostdinc++)
 
-# Target flags ================================================================
-add_flags_if(LIBCXX_BUILD_32_BITS -m32)
-add_flags_if(LIBCXX_TARGET_TRIPLE "-target ${LIBCXX_TARGET_TRIPLE}")
-add_flags_if(LIBCXX_SYSROOT "--sysroot ${LIBCXX_SYSROOT}")
-add_flags_if(LIBCXX_GCC_TOOLCHAIN "-gcc-toolchain ${LIBCXX_GCC_TOOLCHAIN}")
 
 # Warning flags ===============================================================
 add_definitions(-D_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 add_compile_flags_if_supported(
     -Wall -W -Wwrite-strings
-    -Wno-unused-parameter -Wno-long-long
+    -Wno-unused-parameter -Wno-long-long -Wno-user-defined-literals
+    -Wno-covered-switch-default
     -Werror=return-type)
 if (LIBCXX_ENABLE_WERROR)
   add_compile_flags_if_supported(-Werror)
@@ -297,6 +324,9 @@ endif()
 if (LIBCXX_ENABLE_PEDANTIC)
   add_compile_flags_if_supported(-pedantic)
 endif()
+if (LIBCXX_DISABLE_MACRO_CONFLICT_WARNINGS)
+  add_definitions(-D_LIBCPP_DISABLE_MACRO_CONFLICT_WARNINGS)
+endif()
 
 # Exception flags =============================================================
 if (LIBCXX_ENABLE_EXCEPTIONS)
@@ -376,6 +406,7 @@ config_define_if_not(LIBCXX_ENABLE_THREADS _LIBCPP_HAS_NO_THREADS)
 config_define_if_not(LIBCXX_ENABLE_MONOTONIC_CLOCK _LIBCPP_HAS_NO_MONOTONIC_CLOCK)
 config_define_if_not(LIBCXX_ENABLE_THREAD_UNSAFE_C_FUNCTIONS _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS)
 
+config_define_if(LIBCXX_HAS_PTHREAD_API _LIBCPP_HAS_THREAD_API_PTHREAD)
 config_define_if(LIBCXX_HAS_MUSL_LIBC _LIBCPP_HAS_MUSL_LIBC)
 
 if (LIBCXX_NEEDS_SITE_CONFIG)
diff --git a/CREDITS.TXT b/CREDITS.TXT
index 1cf713a68842..ceb12c42b965 100644
--- a/CREDITS.TXT
+++ b/CREDITS.TXT
@@ -37,6 +37,10 @@ E: mclow.lists@gmail.com
 E: marshall@idio.com
 D: C++14 support, patches and bug fixes.
 
+N: Jonathan B Coe
+E: jbcoe@me.com
+D: Implementation of propagate_const.
+
 N: Eric Fiselier
 E: eric@efcs.ca
 D: LFTS support, patches and bug fixes.
diff --git a/LICENSE.TXT b/LICENSE.TXT
index 53352e42dd1f..339e232c68fd 100644
--- a/LICENSE.TXT
+++ b/LICENSE.TXT
@@ -14,7 +14,7 @@ Full text of the relevant licenses is included below.
 University of Illinois/NCSA
 Open Source License
 
-Copyright (c) 2009-2015 by the contributors listed in CREDITS.TXT
+Copyright (c) 2009-2016 by the contributors listed in CREDITS.TXT
 
 All rights reserved.
 
diff --git a/Makefile b/Makefile
deleted file mode 100644
index ab7b5b603a04..000000000000
--- a/Makefile
+++ /dev/null
@@ -1,56 +0,0 @@
-##
-# libc++ Makefile
-##
-
-SRCDIRS = .
-DESTDIR = $(DSTROOT)
-
-OBJROOT=.
-SYMROOT=.
-export TRIPLE=-apple-
-
-ifeq (,$(RC_INDIGO))
-	INSTALL_PREFIX=""
-else
-	INSTALL_PREFIX="$(SDKROOT)"
-endif
-INSTALL_DIR=$(DSTROOT)/$(INSTALL_PREFIX)
-
-.PHONY: help installsrc clean installheaders install
-
-help::
-	@echo "Use make install DSTROOT=<destination>"
-
-installsrc:: $(SRCROOT)
-
-	ditto $(SRCDIRS)/include $(SRCROOT)/include
-	ditto $(SRCDIRS)/lib $(SRCROOT)/lib
-	ditto $(SRCDIRS)/src $(SRCROOT)/src
-	ditto $(SRCDIRS)/Makefile $(SRCROOT)/Makefile
-
-clean::
-
-# The installheaders target is used by clang's runtime/libcxx makefile.
-installheaders::
-	mkdir -p $(HEADER_DIR)/c++/v1/ext
-	(cd $(SRCDIRS)/include && \
-	  tar cf - --exclude=".*" --exclude=support \
-	           --exclude=CMakeLists.txt *) | \
-	  (cd $(HEADER_DIR)/c++/v1 && tar xf -)
-	chmod 755 $(HEADER_DIR)/c++/v1
-	chmod 644 $(HEADER_DIR)/c++/v1/*
-	chmod 755 $(HEADER_DIR)/c++/v1/ext
-	chmod 644 $(HEADER_DIR)/c++/v1/ext/*
-	chmod 755 $(HEADER_DIR)/c++/v1/experimental
-	chmod 644 $(HEADER_DIR)/c++/v1/experimental/*
-
-install::
-
-	cd lib && ./buildit
-	ditto lib/libc++.1.dylib $(SYMROOT)/usr/lib/libc++.1.dylib
-	cd lib && dsymutil -o $(SYMROOT)/libc++.1.dylib.dSYM \
-	  $(SYMROOT)/usr/lib/libc++.1.dylib
-	mkdir -p $(INSTALL_DIR)/usr/lib
-	strip -S -o $(INSTALL_DIR)/usr/lib/libc++.1.dylib \
-	  $(SYMROOT)/usr/lib/libc++.1.dylib
-	cd $(INSTALL_DIR)/usr/lib && ln -s libc++.1.dylib libc++.dylib
diff --git a/benchmarks/unordered_set_operations.bench.cpp b/benchmarks/unordered_set_operations.bench.cpp
new file mode 100644
index 000000000000..c9ee689f69d3
--- /dev/null
+++ b/benchmarks/unordered_set_operations.bench.cpp
@@ -0,0 +1,44 @@
+#include <unordered_set>
+#include <vector>
+#include <cstdint>
+
+#include "benchmark/benchmark_api.h"
+
+template <class IntT>
+std::vector<IntT> getInputs(size_t N) {
+    std::vector<IntT> inputs;
+    for (size_t i=0; i < N; ++i) {
+        inputs.push_back(i);
+    }
+    return inputs;
+}
+
+template <class Container, class Inputs>
+void BM_SetInsert(benchmark::State& st, Container c, Inputs const& in) {
+    const auto end = in.end();
+    while (st.KeepRunning()) {
+        c.clear();
+        for (auto it = in.begin(); it != end; ++it) {
+            benchmark::DoNotOptimize(c.insert(*it));
+        }
+        benchmark::DoNotOptimize(c);
+    }
+}
+BENCHMARK_CAPTURE(BM_SetInsert, uint32_insert,
+    std::unordered_set<uint32_t>{}, getInputs<uint32_t>(1024));
+
+template <class Container, class Inputs>
+void BM_SetFind(benchmark::State& st, Container c, Inputs const& in) {
+    c.insert(in.begin(), in.end());
+    const auto end = in.end();
+    while (st.KeepRunning()) {
+        for (auto it = in.begin(); it != end; ++it) {
+            benchmark::DoNotOptimize(c.find(*it));
+        }
+    }
+}
+BENCHMARK_CAPTURE(BM_SetFind, uint32_lookup,
+    std::unordered_set<uint32_t>{}, getInputs<uint32_t>(1024));
+
+
+BENCHMARK_MAIN()
diff --git a/cmake/Modules/CheckLibcxxAtomic.cmake b/cmake/Modules/CheckLibcxxAtomic.cmake
new file mode 100644
index 000000000000..4ff343236fea
--- /dev/null
+++ b/cmake/Modules/CheckLibcxxAtomic.cmake
@@ -0,0 +1,41 @@
+INCLUDE(CheckCXXSourceCompiles)
+
+# Sometimes linking against libatomic is required for atomic ops, if
+# the platform doesn't support lock-free atomics.
+#
+# We could modify LLVM's CheckAtomic module and have it check for 64-bit
+# atomics instead. However, we would like to avoid careless uses of 64-bit
+# atomics inside LLVM over time on 32-bit platforms.
+
+function(check_cxx_atomics varname)
+  set(OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
+  set(CMAKE_REQUIRED_FLAGS "-std=c++11 -nostdinc++ -isystem ${LIBCXX_SOURCE_DIR}/include")
+  if (${LIBCXX_GCC_TOOLCHAIN})
+    set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} --gcc-toolchain=${LIBCXX_GCC_TOOLCHAIN}")
+  endif()
+  check_cxx_source_compiles("
+#include <cstdint>
+#include <atomic>
+std::atomic<uintptr_t> x;
+std::atomic<uintmax_t> y;
+int main() {
+  return x + y;
+}
+" ${varname})
+  set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS})
+endfunction(check_cxx_atomics)
+
+check_cxx_atomics(LIBCXX_HAVE_CXX_ATOMICS_WITHOUT_LIB)
+check_library_exists(atomic __atomic_fetch_add_8 "" LIBCXX_HAS_ATOMIC_LIB)
+# If not, check if the library exists, and atomics work with it.
+if(NOT LIBCXX_HAVE_CXX_ATOMICS_WITHOUT_LIB)
+  if(LIBCXX_HAS_ATOMIC_LIB)
+    list(APPEND CMAKE_REQUIRED_LIBRARIES "atomic")
+    check_cxx_atomics(LIBCXX_HAVE_CXX_ATOMICS_WITH_LIB)
+    if (NOT LIBCXX_HAVE_CXX_ATOMICS_WITH_LIB)
+      message(WARNING "Host compiler must support std::atomic!")
+    endif()
+  else()
+    message(WARNING "Host compiler appears to require libatomic, but cannot find it.")
+  endif()
+endif()
diff --git a/cmake/Modules/HandleLibCXXABI.cmake b/cmake/Modules/HandleLibCXXABI.cmake
index d9c652d87bad..c655adff718e 100644
--- a/cmake/Modules/HandleLibCXXABI.cmake
+++ b/cmake/Modules/HandleLibCXXABI.cmake
@@ -21,9 +21,11 @@ macro(setup_abi_lib abidefines abilib abifiles abidirs)
     CACHE PATH
     "Paths to C++ ABI header directories separated by ';'." FORCE
     )
-
+  set(LIBCXX_CXX_ABI_LIBRARY_PATH "${LIBCXX_CXX_ABI_LIBRARY_PATH}"
+    CACHE PATH
+    "Paths to C++ ABI library directory"
+    )
   set(LIBCXX_CXX_ABI_LIBRARY ${abilib})
-
   set(LIBCXX_ABILIB_FILES ${abifiles})
 
   file(MAKE_DIRECTORY "${CMAKE_BINARY_DIR}/include")
diff --git a/cmake/Modules/HandleLibcxxFlags.cmake b/cmake/Modules/HandleLibcxxFlags.cmake
index bb886fa8a01f..325c1bdf7bcb 100644
--- a/cmake/Modules/HandleLibcxxFlags.cmake
+++ b/cmake/Modules/HandleLibcxxFlags.cmake
@@ -35,6 +35,11 @@ macro(remove_flags)
   endforeach()
 endmacro(remove_flags)
 
+macro(check_flag_supported flag)
+    mangle_name("${flag}" flagname)
+    check_cxx_compiler_flag("${flag}" "LIBCXX_SUPPORTS_${flagname}_FLAG")
+endmacro()
+
 # Add a macro definition if condition is true.
 macro(define_if condition def)
   if (${condition})
@@ -71,6 +76,26 @@ macro(config_define value def)
   set(LIBCXX_NEEDS_SITE_CONFIG ON)
 endmacro()
 
+# Add a list of flags to all of 'CMAKE_CXX_FLAGS', 'CMAKE_C_FLAGS',
+# 'LIBCXX_COMPILE_FLAGS' and 'LIBCXX_LINK_FLAGS'.
+macro(add_target_flags)
+  foreach(value ${ARGN})
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${value}")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${value}")
+    list(APPEND LIBCXX_COMPILE_FLAGS ${value})
+    list(APPEND LIBCXX_LINK_FLAGS ${value})
+  endforeach()
+endmacro()
+
+# If the specified 'condition' is true then add a list of flags to
+# all of 'CMAKE_CXX_FLAGS', 'CMAKE_C_FLAGS', 'LIBCXX_COMPILE_FLAGS'
+# and 'LIBCXX_LINK_FLAGS'.
+macro(add_target_flags_if condition)
+  if (${condition})
+    add_target_flags(${ARGN})
+  endif()
+endmacro()
+
 # Add a specified list of flags to both 'LIBCXX_COMPILE_FLAGS' and
 # 'LIBCXX_LINK_FLAGS'.
 macro(add_flags)
diff --git a/cmake/Modules/HandleOutOfTreeLLVM.cmake b/cmake/Modules/HandleOutOfTreeLLVM.cmake
index 6215be7f586a..9c5dd8109261 100644
--- a/cmake/Modules/HandleOutOfTreeLLVM.cmake
+++ b/cmake/Modules/HandleOutOfTreeLLVM.cmake
@@ -35,7 +35,7 @@ macro(find_llvm_parts)
     set(LLVM_INCLUDE_DIR ${INCLUDE_DIR} CACHE PATH "Path to llvm/include")
     set(LLVM_BINARY_DIR ${LLVM_OBJ_ROOT} CACHE PATH "Path to LLVM build tree")
     set(LLVM_MAIN_SRC_DIR ${MAIN_SRC_DIR} CACHE PATH "Path to LLVM source tree")
-    set(LLVM_CMAKE_PATH "${LLVM_BINARY_DIR}/share/llvm/cmake")
+    set(LLVM_CMAKE_PATH "${LLVM_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX}/cmake/llvm")
   else()
     set(LLVM_FOUND OFF)
     return()
@@ -93,14 +93,6 @@ if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
   endif()
   set(LLVM_LIT_ARGS "${LIT_ARGS_DEFAULT}" CACHE STRING "Default options for lit")
 
-  # Make sure we can use the console pool for recent cmake and ninja > 1.5
-  # Needed for add_lit_testsuite
-  if(CMAKE_VERSION VERSION_LESS 3.1.20141117)
-    set(cmake_3_2_USES_TERMINAL)
-  else()
-    set(cmake_3_2_USES_TERMINAL USES_TERMINAL)
-  endif()
-
   # Required doc configuration
   if (LLVM_ENABLE_SPHINX)
     message(STATUS "Sphinx enabled.")
diff --git a/cmake/config-ix.cmake b/cmake/config-ix.cmake
index c05597ea73dd..3e6c3599d23d 100644
--- a/cmake/config-ix.cmake
+++ b/cmake/config-ix.cmake
@@ -1,5 +1,6 @@
 include(CheckLibraryExists)
 include(CheckCXXCompilerFlag)
+include(CheckLibcxxAtomic)
 
 # Check compiler flags
 
diff --git a/docs/BuildingLibcxx.rst b/docs/BuildingLibcxx.rst
index f00ce4f9cff1..36866b13ef7b 100644
--- a/docs/BuildingLibcxx.rst
+++ b/docs/BuildingLibcxx.rst
@@ -1,3 +1,4 @@
+.. _BuildingLibcxx:
 
 ===============
 Building libc++
@@ -6,6 +7,8 @@ Building libc++
 .. contents::
   :local:
 
+.. _build instructions:
+
 Getting Started
 ===============
 
@@ -34,8 +37,7 @@ The basic steps needed to build libc++ are:
 
 #. Configure and build libc++ with libc++abi:
 
-   CMake is the only supported configuration system. Unlike other LLVM
-   projects autotools is not supported for either libc++ or libc++abi.
+   CMake is the only supported configuration system.
 
    Clang is the preferred compiler when building and using libc++.
 
@@ -120,6 +122,18 @@ CMake docs or execute ``cmake --help-variable VARIABLE_NAME``.
 libc++ specific options
 -----------------------
 
+.. option:: LIBCXX_INSTALL_LIBRARY:BOOL
+
+  **Default**: ``ON``
+
+  Toggle the installation of the library portion of libc++.
+
+.. option:: LIBCXX_INSTALL_HEADERS:BOOL
+
+  **Default**: ``ON``
+
+  Toggle the installation of the libc++ headers.
+
 .. option:: LIBCXX_ENABLE_ASSERTIONS:BOOL
 
   **Default**: ``ON``
@@ -144,6 +158,33 @@ libc++ specific options
   Extra suffix to append to the directory where libraries are to be installed.
   This option overrides :option:`LLVM_LIBDIR_SUFFIX`.
 
+
+.. _libc++experimental options:
+
+libc++experimental Specific Options
+------------------------------------
+
+.. option:: LIBCXX_ENABLE_EXPERIMENTAL_LIBRARY:BOOL
+
+  **Default**: ``ON``
+
+  Build and test libc++experimental.a.
+
+.. option:: LIBCXX_INSTALL_EXPERIMENTAL_LIBRARY:BOOL
+
+  **Default**: ``OFF``
+
+  Install libc++experimental.a alongside libc++.
+
+
+.. option:: LIBCXX_ENABLE_FILESYSTEM:BOOL
+
+  **Default**: ``LIBCXX_ENABLE_EXPERIMENTAL_LIBRARY``
+
+  Build filesystem as part of libc++experimental.a. This allows filesystem
+  to be disabled without turning off the entire experimental library.
+
+
 .. _ABI Library Specific Options:
 
 ABI Library Specific Options
@@ -304,3 +345,72 @@ own copy of libsupc++ and this can lead to subtle problems.
   $ make install
 
 You can now run clang with -stdlib=libc++.
+
+
+.. _libcxxrt_ref:
+
+Using libcxxrt on Linux
+------------------------
+
+You will need to keep the source tree of `libcxxrt`_ available
+on your build machine and your copy of the libcxxrt shared library must
+be placed where your linker will find it.
+
+We can now run CMake like:
+
+.. code-block:: bash
+
+  $ CC=clang CXX=clang++ cmake -G "Unix Makefiles" \
+          -DLIBCXX_CXX_ABI=libcxxrt \
+          -DLIBCXX_CXX_ABI_INCLUDE_PATHS=path/to/libcxxrt-sources/src \
+                -DCMAKE_BUILD_TYPE=Release \
+                -DCMAKE_INSTALL_PREFIX=/usr \
+                <libc++-source-directory>
+  $ make cxx
+  $ make install
+
+Unfortunately you can't simply run clang with "-stdlib=libc++" at this point, as
+clang is set up to link for libc++ linked to libsupc++.  To get around this
+you'll have to set up your linker yourself (or patch clang).  For example,
+
+.. code-block:: bash
+
+  $ clang++ -stdlib=libc++ helloworld.cpp \
+            -nodefaultlibs -lc++ -lcxxrt -lm -lc -lgcc_s -lgcc
+
+Alternately, you could just add libcxxrt to your libraries list, which in most
+situations will give the same result:
+
+.. code-block:: bash
+
+  $ clang++ -stdlib=libc++ helloworld.cpp -lcxxrt
+
+.. _`libcxxrt`: https://github.com/pathscale/libcxxrt/
+
+
+Using a local ABI library installation
+---------------------------------------
+
+.. warning::
+  This is not recommended in almost all cases.
+
+These instructions should only be used when you can't install your ABI library.
+
+Normally you must link libc++ against a ABI shared library that the
+linker can find.  If you want to build and test libc++ against an ABI
+library not in the linker's path you needq to set
+``-DLIBCXX_CXX_ABI_LIBRARY_PATH=/path/to/abi/lib`` when configuring CMake.
+
+An example build using libc++abi would look like:
+
+.. code-block:: bash
+
+  $ CC=clang CXX=clang++ cmake \
+              -DLIBCXX_CXX_ABI=libc++abi  \
+              -DLIBCXX_CXX_ABI_INCLUDE_PATHS="/path/to/libcxxabi/include" \
+              -DLIBCXX_CXX_ABI_LIBRARY_PATH="/path/to/libcxxabi-build/lib" \
+               path/to/libcxx
+  $ make
+
+When testing libc++ LIT will automatically link against the proper ABI
+library.
diff --git a/docs/TestingLibcxx.rst b/docs/TestingLibcxx.rst
index 98162d9c2e05..9226ae17023e 100644
--- a/docs/TestingLibcxx.rst
+++ b/docs/TestingLibcxx.rst
@@ -98,7 +98,7 @@ configuration. Passing the option on the command line will override the default.
 
 .. program:: lit
 
-.. option:: cxx_under_test=<path/to/compiler>
+.. option:: --cxx_under_test=<path/to/compiler>
 
   Specify the compiler used to build the tests.
 
@@ -108,37 +108,46 @@ configuration. Passing the option on the command line will override the default.
 
   Change the standard version used when building the tests.
 
-.. option:: libcxx_site_config=<path/to/lit.site.cfg>
+.. option:: --libcxx_site_config=<path/to/lit.site.cfg>
 
   Specify the site configuration to use when running the tests.  This option
   overrides the enviroment variable LIBCXX_SITE_CONFIG.
 
-.. option:: libcxx_headers=<path/to/headers>
+.. option:: --libcxx_headers=<path/to/headers>
 
   Specify the libc++ headers that are tested. By default the headers in the
   source tree are used.
 
-.. option:: libcxx_library=<path/to/libc++.so>
+.. option:: --cxx_library_root=<path/to/lib/>
 
-  Specify the libc++ library that is tested. By default the library in the
-  build directory is used. This option cannot be used when use_system_lib is
-  provided.
+  Specify the directory of the libc++ library to be tested. By default the
+  library folder of the build directory is used. This option cannot be used
+  when use_system_lib is provided.
 
-.. option:: use_system_lib=<bool>
+
+.. option:: --cxx_runtime_root=<path/to/lib/>
+
+  Specify the directory of the libc++ library to use at runtime. This directory
+  is not added to the linkers search path. This can be used to compile tests
+  against one version of libc++ and run them using another. The default value
+  for this option is `cxx_library_root`. This option cannot be used
+  when use_system_lib is provided.
+
+.. option:: --use_system_lib=<bool>
 
   **Default**: False
 
   Enable or disable testing against the installed version of libc++ library.
   Note: This does not use the installed headers.
 
-.. option:: use_lit_shell=<bool>
+.. option:: --use_lit_shell=<bool>
 
   Enable or disable the use of LIT's internal shell in ShTests. If the
   environment variable LIT_USE_INTERNAL_SHELL is present then that is used as
   the default value. Otherwise the default value is True on Windows and False
   on every other platform.
 
-.. option:: no_default_flags=<bool>
+.. option:: --no_default_flags=<bool>
 
   **Default**: False
 
@@ -146,16 +155,16 @@ configuration. Passing the option on the command line will override the default.
   option is used only flags specified using the compile_flags and link_flags
   will be used.
 
-.. option:: compile_flags="<list-of-args>"
+.. option:: --compile_flags="<list-of-args>"
 
   Specify additional compile flags as a space delimited string.
   Note: This options should not be used to change the standard version used.
 
-.. option:: link_flags="<list-of-args>"
+.. option:: --link_flags="<list-of-args>"
 
   Specify additional link flags as a space delimited string.
 
-.. option:: debug_level=<level>
+.. option:: --debug_level=<level>
 
   **Values**: 0, 1
 
diff --git a/docs/UsingLibcxx.rst b/docs/UsingLibcxx.rst
index 2a117917638c..514ed14b7464 100644
--- a/docs/UsingLibcxx.rst
+++ b/docs/UsingLibcxx.rst
@@ -49,7 +49,30 @@ An example of using ``LD_LIBRARY_PATH``:
   $ export LD_LIBRARY_PATH=<libcxx-install-prefix>/lib
   $ ./a.out # Searches for libc++ along LD_LIBRARY_PATH
 
+Using libc++experimental and ``<experimental/...>``
+=====================================================
 
+Libc++ provides implementations of experimental technical specifications
+in a separate library, ``libc++experimental.a``. Users of ``<experimental/...>``
+headers may be required to link ``-lc++experimental``.
+
+.. code-block:: bash
+
+  $ clang++ -std=c++14 -stdlib=libc++ test.cpp -lc++experimental
+
+Libc++experimental.a may not always be available, even when libc++ is already
+installed. For information on building libc++experimental from source see
+:ref:`Building Libc++ <build instructions>` and
+:ref:`libc++experimental CMake Options <libc++experimental options>`.
+
+Also see the `Experimental Library Implementation Status <http://libcxx.llvm.org/ts1z_status.html>`__
+page.
+
+.. warning::
+  Experimental libraries are Experimental.
+    * The contents of the ``<experimental/...>`` headers and ``libc++experimental.a``
+      library will not remain compatible between versions.
+    * No guarantees of API or ABI stability are provided.
 
 Using libc++ on Linux
 =====================
@@ -87,3 +110,16 @@ not just libstdc++ so they must be manually linked. For example:
 
   $ g++ -nostdinc++ -I<libcxx-install-prefix>/include/c++/v1 \
          test.cpp -nodefaultlibs -lc++ -lc++abi -lm -lc -lgcc_s -lgcc
+
+
+GDB Pretty printers for libc++
+------------------------------
+
+GDB does not support pretty-printing of libc++ symbols by default. Unfortunately
+libc++ does not provide pretty-printers itself. However there are 3rd
+party implementations available and although they are not officially
+supported by libc++ they may be useful to users.
+
+Known 3rd Party Implementations Include:
+
+* `Koutheir's libc++ pretty-printers <https://github.com/koutheir/libcxx-pretty-printers>`_.
diff --git a/docs/conf.py b/docs/conf.py
index 915daa47a514..e385406b9923 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -40,16 +40,16 @@ master_doc = 'index'
 
 # General information about the project.
 project = u'libc++'
-copyright = u'2011-2015, LLVM Project'
+copyright = u'2011-2016, LLVM Project'
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
 # built documents.
 #
 # The short X.Y version.
-version = '3.8'
+version = '3.9'
 # The full version, including alpha/beta/rc tags.
-release = '3.8'
+release = '3.9'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
diff --git a/include/CMakeLists.txt b/include/CMakeLists.txt
index e16dc8b4de63..219d1b730839 100644
--- a/include/CMakeLists.txt
+++ b/include/CMakeLists.txt
@@ -19,7 +19,7 @@ file(COPY .
 if (LIBCXX_INSTALL_HEADERS)
   install(DIRECTORY .
     DESTINATION include/c++/v1
-    COMPONENT libcxx
+    COMPONENT libcxx-headers
     FILES_MATCHING
     ${LIBCXX_HEADER_PATTERN}
     PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
@@ -41,12 +41,23 @@ if (LIBCXX_INSTALL_HEADERS)
     # Add a target that executes the generation commands.
     add_custom_target(generate_config_header ALL
       DEPENDS ${LIBCXX_BINARY_DIR}/__generated_config)
+    set(generated_config_deps generate_config_header)
     # Install the generated header as __config.
     install(FILES ${LIBCXX_BINARY_DIR}/__generated_config
       DESTINATION include/c++/v1
       PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
       RENAME __config
-      COMPONENT libcxx)
+      COMPONENT libcxx-headers)
+  endif()
+
+  if (NOT CMAKE_CONFIGURATION_TYPES)
+    # this target is just needed as a placeholder for the distribution target
+    add_custom_target(libcxx-headers)
+    add_custom_target(install-libcxx-headers
+                      DEPENDS libcxx-headers ${generated_config_deps}
+                      COMMAND "${CMAKE_COMMAND}"
+                              -DCMAKE_INSTALL_COMPONENT=libcxx-headers
+                              -P "${CMAKE_BINARY_DIR}/cmake_install.cmake")
   endif()
 
 endif()
diff --git a/include/__bsd_locale_defaults.h b/include/__bsd_locale_defaults.h
new file mode 100644
index 000000000000..f315ca2949e3
--- /dev/null
+++ b/include/__bsd_locale_defaults.h
@@ -0,0 +1,33 @@
+// -*- C++ -*-
+//===---------------------- __bsd_locale_defaults.h -----------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+// The BSDs have lots of *_l functions.  We don't want to define those symbols
+// on other platforms though, for fear of conflicts with user code.  So here,
+// we will define the mapping from an internal macro to the real BSD symbol.
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_BSD_LOCALE_DEFAULTS_H
+#define _LIBCPP_BSD_LOCALE_DEFAULTS_H
+
+#define __libcpp_mb_cur_max_l(loc)                          MB_CUR_MAX_L(loc)
+#define __libcpp_btowc_l(ch, loc)                           btowc_l(ch, loc)
+#define __libcpp_wctob_l(wch, loc)                          wctob_l(wch, loc)
+#define __libcpp_wcsnrtombs_l(dst, src, nwc, len, ps, loc)  wcsnrtombs_l(dst, src, nwc, len, ps, loc)
+#define __libcpp_wcrtomb_l(src, wc, ps, loc)                wcrtomb_l(src, wc, ps, loc)
+#define __libcpp_mbsnrtowcs_l(dst, src, nms, len, ps, loc)  mbsnrtowcs_l(dst, src, nms, len, ps, loc)
+#define __libcpp_mbrtowc_l(pwc, s, n, ps, l)                mbrtowc_l(pwc, s, n, ps, l)
+#define __libcpp_mbtowc_l(pwc, pmb, max, l)                 mbtowc_l(pwc, pmb, max, l)
+#define __libcpp_mbrlen_l(s, n, ps, l)                      mbrlen_l(s, n, ps, l)
+#define __libcpp_localeconv_l(l)                            localeconv_l(l)
+#define __libcpp_mbsrtowcs_l(dest, src, len, ps, l)         mbsrtowcs_l(dest, src, len, ps, l)
+#define __libcpp_snprintf_l(...)                            snprintf_l(__VA_ARGS__)
+#define __libcpp_asprintf_l(...)                            asprintf_l(__VA_ARGS__)
+#define __libcpp_sscanf_l(...)                              sscanf_l(__VA_ARGS__)
+
+#endif // _LIBCPP_BSD_LOCALE_DEFAULTS_H
diff --git a/include/__bsd_locale_fallbacks.h b/include/__bsd_locale_fallbacks.h
new file mode 100644
index 000000000000..cbc8ad226fd2
--- /dev/null
+++ b/include/__bsd_locale_fallbacks.h
@@ -0,0 +1,138 @@
+// -*- C++ -*-
+//===---------------------- __bsd_locale_fallbacks.h ----------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+// The BSDs have lots of *_l functions.  This file provides reimplementations
+// of those functions for non-BSD platforms.
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_BSD_LOCALE_FALLBACKS_DEFAULTS_H
+#define _LIBCPP_BSD_LOCALE_FALLBACKS_DEFAULTS_H
+
+#include <stdlib.h>
+#include <memory>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+typedef _VSTD::remove_pointer<locale_t>::type __use_locale_struct;
+typedef _VSTD::unique_ptr<__use_locale_struct, decltype(&uselocale)> __locale_raii;
+
+inline _LIBCPP_ALWAYS_INLINE
+decltype(MB_CUR_MAX) __libcpp_mb_cur_max_l(locale_t __l)
+{
+    __locale_raii __current( uselocale(__l), uselocale );
+    return MB_CUR_MAX;
+}
+
+inline _LIBCPP_ALWAYS_INLINE
+wint_t __libcpp_btowc_l(int __c, locale_t __l)
+{
+    __locale_raii __current( uselocale(__l), uselocale );
+    return btowc(__c);
+}
+
+inline _LIBCPP_ALWAYS_INLINE
+int __libcpp_wctob_l(wint_t __c, locale_t __l)
+{
+    __locale_raii __current( uselocale(__l), uselocale );
+    return wctob(__c);
+}
+
+inline _LIBCPP_ALWAYS_INLINE
+size_t __libcpp_wcsnrtombs_l(char *__dest, const wchar_t **__src, size_t __nwc,
+                         size_t __len, mbstate_t *__ps, locale_t __l)
+{
+    __locale_raii __current( uselocale(__l), uselocale );
+    return wcsnrtombs(__dest, __src, __nwc, __len, __ps);
+}
+
+inline _LIBCPP_ALWAYS_INLINE
+size_t __libcpp_wcrtomb_l(char *__s, wchar_t __wc, mbstate_t *__ps, locale_t __l)
+{
+    __locale_raii __current( uselocale(__l), uselocale );
+    return wcrtomb(__s, __wc, __ps);
+}
+
+inline _LIBCPP_ALWAYS_INLINE
+size_t __libcpp_mbsnrtowcs_l(wchar_t * __dest, const char **__src, size_t __nms,
+                      size_t __len, mbstate_t *__ps, locale_t __l)
+{
+    __locale_raii __current( uselocale(__l), uselocale );
+    return mbsnrtowcs(__dest, __src, __nms, __len, __ps);
+}
+
+inline _LIBCPP_ALWAYS_INLINE
+size_t __libcpp_mbrtowc_l(wchar_t *__pwc, const char *__s, size_t __n,
+                   mbstate_t *__ps, locale_t __l)
+{
+    __locale_raii __current( uselocale(__l), uselocale );
+    return mbrtowc(__pwc, __s, __n, __ps);
+}
+
+inline _LIBCPP_ALWAYS_INLINE
+int __libcpp_mbtowc_l(wchar_t *__pwc, const char *__pmb, size_t __max, locale_t __l)
+{
+    __locale_raii __current( uselocale(__l), uselocale );
+    return mbtowc(__pwc, __pmb, __max);
+}
+
+inline _LIBCPP_ALWAYS_INLINE
+size_t __libcpp_mbrlen_l(const char *__s, size_t __n, mbstate_t *__ps, locale_t __l)
+{
+    __locale_raii __current( uselocale(__l), uselocale );
+    return mbrlen(__s, __n, __ps);
+}
+
+inline _LIBCPP_ALWAYS_INLINE
+lconv *__libcpp_localeconv_l(locale_t __l)
+{
+    __locale_raii __current( uselocale(__l), uselocale );
+    return localeconv();
+}
+
+inline _LIBCPP_ALWAYS_INLINE
+size_t __libcpp_mbsrtowcs_l(wchar_t *__dest, const char **__src, size_t __len,
+                     mbstate_t *__ps, locale_t __l)
+{
+    __locale_raii __current( uselocale(__l), uselocale );
+    return mbsrtowcs(__dest, __src, __len, __ps);
+}
+
+inline
+int __libcpp_snprintf_l(char *__s, size_t __n, locale_t __l, const char *__format, ...) {
+    va_list __va;
+    va_start(__va, __format);
+    __locale_raii __current( uselocale(__l), uselocale );
+    int __res = vsnprintf(__s, __n, __format, __va);
+    va_end(__va);
+    return __res;
+}
+
+inline
+int __libcpp_asprintf_l(char **__s, locale_t __l, const char *__format, ...) {
+    va_list __va;
+    va_start(__va, __format);
+    __locale_raii __current( uselocale(__l), uselocale );
+    int __res = vasprintf(__s, __format, __va);
+    va_end(__va);
+    return __res;
+}
+
+inline
+int __libcpp_sscanf_l(const char *__s, locale_t __l, const char *__format, ...) {
+    va_list __va;
+    va_start(__va, __format);
+    __locale_raii __current( uselocale(__l), uselocale );
+    int __res = vsscanf(__s, __format, __va);
+    va_end(__va);
+    return __res;
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_BSD_LOCALE_FALLBACKS_DEFAULTS_H
diff --git a/include/__config b/include/__config
index db5a832b6cd1..3edb9de017ab 100644
--- a/include/__config
+++ b/include/__config
@@ -27,7 +27,7 @@
 #define _GNUC_VER 0
 #endif
 
-#define _LIBCPP_VERSION 3800
+#define _LIBCPP_VERSION 3900
 
 #ifndef _LIBCPP_ABI_VERSION
 #define _LIBCPP_ABI_VERSION 1
@@ -41,6 +41,22 @@
 #define _LIBCPP_ABI_INCOMPLETE_TYPES_IN_DEQUE
 // Fix undefined behavior in how std::list stores it's linked nodes.
 #define _LIBCPP_ABI_LIST_REMOVE_NODE_POINTER_UB
+// Fix undefined behavior in  how __tree stores its end and parent nodes.
+#define _LIBCPP_ABI_TREE_REMOVE_NODE_POINTER_UB
+#define _LIBCPP_ABI_FORWARD_LIST_REMOVE_NODE_POINTER_UB
+#define _LIBCPP_ABI_FIX_UNORDERED_CONTAINER_SIZE_TYPE
+#define _LIBCPP_ABI_VARIADIC_LOCK_GUARD
+#elif _LIBCPP_ABI_VERSION == 1
+// Feature macros for disabling pre ABI v1 features. All of these options
+// are deprecated.
+#if defined(__FreeBSD__)
+#define _LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR
+#endif
+#endif
+
+#ifdef _LIBCPP_TRIVIAL_PAIR_COPY_CTOR
+#error "_LIBCPP_TRIVIAL_PAIR_COPY_CTOR" is no longer supported. \
+       use _LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR instead
 #endif
 
 #define _LIBCPP_CONCAT1(_LIBCPP_X,_LIBCPP_Y) _LIBCPP_X##_LIBCPP_Y
@@ -178,6 +194,12 @@
 # endif
 #endif  // !defined(_LIBCPP_LITTLE_ENDIAN) || !defined(_LIBCPP_BIG_ENDIAN)
 
+#if __has_attribute(__no_sanitize__)
+#define _LIBCPP_NO_CFI __attribute__((__no_sanitize__("cfi")))
+#else
+#define _LIBCPP_NO_CFI
+#endif
+
 #ifdef _WIN32
 
 // only really useful for a DLL
@@ -236,6 +258,12 @@
 #  endif
 #endif
 
+#ifndef _LIBCPP_PREFERRED_OVERLOAD
+#  if __has_attribute(__enable_if__)
+#    define _LIBCPP_PREFERRED_OVERLOAD __attribute__ ((__enable_if__(true, "")))
+#  endif
+#endif
+
 #ifndef _LIBCPP_TYPE_VIS_ONLY
 # define _LIBCPP_TYPE_VIS_ONLY _LIBCPP_TYPE_VIS
 #endif
@@ -283,7 +311,7 @@ typedef __char16_t char16_t;
 typedef __char32_t char32_t;
 #endif
 
-#if !(__has_feature(cxx_exceptions))
+#if !(__has_feature(cxx_exceptions)) && !defined(_LIBCPP_NO_EXCEPTIONS)
 #define _LIBCPP_NO_EXCEPTIONS
 #endif
 
@@ -305,8 +333,6 @@ typedef __char32_t char32_t;
 #  define _LIBCPP_NORETURN __attribute__ ((noreturn))
 #endif
 
-#define _LIBCPP_UNUSED __attribute__((__unused__))
-
 #if !(__has_feature(cxx_default_function_template_args))
 #define _LIBCPP_HAS_NO_DEFAULT_FUNCTION_TEMPLATE_ARGS
 #endif
@@ -434,8 +460,8 @@ namespace std {
 #endif
 
 // Allow for build-time disabling of unsigned integer sanitization
-#ifndef _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
-#define _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK __attribute((no_sanitize("unsigned-integer-overflow")))
+#if !defined(_LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK) && __has_attribute(no_sanitize)
+#define _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK __attribute__((__no_sanitize__("unsigned-integer-overflow")))
 #endif 
 
 #elif defined(__GNUC__)
@@ -445,8 +471,6 @@ namespace std {
 
 #define _LIBCPP_NORETURN __attribute__((noreturn))
 
-#define _LIBCPP_UNUSED __attribute__((__unused__))
-
 #if _GNUC_VER >= 407
 #define _LIBCPP_UNDERLYING_TYPE(T) __underlying_type(T)
 #define _LIBCPP_IS_LITERAL(T) __is_literal_type(T)
@@ -461,8 +485,6 @@ namespace std {
 #define _LIBCPP_NO_EXCEPTIONS
 #endif
 
-#define _LIBCPP_HAS_NO_TEMPLATE_ALIASES
-
 // constexpr was added to GCC in 4.6.
 #if _GNUC_VER < 406
 #define _LIBCPP_HAS_NO_CONSTEXPR
@@ -494,6 +516,7 @@ namespace std {
 #define _LIBCPP_HAS_NO_VARIADICS
 #define _LIBCPP_HAS_NO_RVALUE_REFERENCES
 #define _LIBCPP_HAS_NO_STRONG_ENUMS
+#define _LIBCPP_HAS_NO_TEMPLATE_ALIASES
 #define _LIBCPP_HAS_NO_NOEXCEPT
 
 #else  // __GXX_EXPERIMENTAL_CXX0X__
@@ -517,6 +540,7 @@ namespace std {
 #if _GNUC_VER < 406
 #define _LIBCPP_HAS_NO_NOEXCEPT
 #define _LIBCPP_HAS_NO_NULLPTR
+#define _LIBCPP_HAS_NO_TEMPLATE_ALIASES
 #endif
 
 #if _GNUC_VER < 407
@@ -552,7 +576,6 @@ using namespace _LIBCPP_NAMESPACE __attribute__((__strong__));
 #define _LIBCPP_HAS_NO_NOEXCEPT
 #define __alignof__ __alignof
 #define _LIBCPP_NORETURN __declspec(noreturn)
-#define _LIBCPP_UNUSED
 #define _ALIGNAS(x) __declspec(align(x))
 #define _LIBCPP_HAS_NO_VARIADICS
 
@@ -574,7 +597,6 @@ namespace std {
 #define _ALIGNAS_TYPE(x) __attribute__((__aligned__(__alignof(x))))
 #define _ATTRIBUTE(x) __attribute__((x))
 #define _LIBCPP_NORETURN __attribute__((noreturn))
-#define _LIBCPP_UNUSED
 
 #define _LIBCPP_HAS_NO_DEFAULT_FUNCTION_TEMPLATE_ARGS
 #define _LIBCPP_HAS_NO_TEMPLATE_ALIASES
@@ -655,6 +677,12 @@ template <unsigned> struct __static_assert_check {};
 #define _LIBCPP_DEFAULT = default;
 #endif
 
+#ifdef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
+#define _LIBCPP_EQUAL_DELETE
+#else
+#define _LIBCPP_EQUAL_DELETE = delete
+#endif
+
 #ifdef __GNUC__
 #define _NOALIAS __attribute__((__malloc__))
 #else
@@ -712,10 +740,12 @@ template <unsigned> struct __static_assert_check {};
 #define _LIBCPP_LOCALE__L_EXTENSIONS 1
 #endif
 
-#if !defined(_WIN32) && !defined(__ANDROID__) && !defined(_NEWLIB_VERSION) && \
-    !defined(__CloudABI__)
+#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
+// Most unix variants have catopen.  These are the specific ones that don't.
+#if !defined(_WIN32) && !defined(__ANDROID__) && !defined(_NEWLIB_VERSION)
 #define _LIBCPP_HAS_CATOPEN 1
 #endif
+#endif
 
 #ifdef __FreeBSD__
 #define _DECLARE_C99_LDBL_MATH 1
@@ -729,17 +759,13 @@ template <unsigned> struct __static_assert_check {};
 #define _LIBCPP_WCTYPE_IS_MASK
 #endif
 
-#ifndef _LIBCPP_TRIVIAL_PAIR_COPY_CTOR
-#  define _LIBCPP_TRIVIAL_PAIR_COPY_CTOR 1
-#endif
-
 #ifndef _LIBCPP_STD_VER
 #  if  __cplusplus <= 201103L
 #    define _LIBCPP_STD_VER 11
 #  elif __cplusplus <= 201402L
 #    define _LIBCPP_STD_VER 14
 #  else
-#    define _LIBCPP_STD_VER 15  // current year, or date of c++17 ratification
+#    define _LIBCPP_STD_VER 16  // current year, or date of c++17 ratification
 #  endif
 #endif  // _LIBCPP_STD_VER
 
@@ -763,6 +789,12 @@ template <unsigned> struct __static_assert_check {};
 #define _LIBCPP_CONSTEXPR_AFTER_CXX11
 #endif
 
+#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_CXX14_CONSTEXPR)
+#define _LIBCPP_CONSTEXPR_AFTER_CXX14 constexpr
+#else
+#define _LIBCPP_CONSTEXPR_AFTER_CXX14
+#endif
+
 #ifdef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 #  define _LIBCPP_EXPLICIT_MOVE(x) _VSTD::move(x)
 #else
@@ -790,6 +822,25 @@ extern "C" void __sanitizer_annotate_contiguous_container(
 #  define _LIBCPP_WEAK __attribute__((__weak__))
 #endif
 
+// Thread API
+#if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_HAS_THREAD_API_PTHREAD)
+# if defined(__FreeBSD__) || \
+    defined(__NetBSD__) || \
+    defined(__linux__) || \
+    defined(__APPLE__) || \
+    defined(__CloudABI__) || \
+    defined(__sun__)
+#  define _LIBCPP_HAS_THREAD_API_PTHREAD
+# else
+#  error "No thread API"
+# endif // _LIBCPP_HAS_THREAD_API
+#endif // _LIBCPP_HAS_NO_THREADS
+
+#if defined(_LIBCPP_HAS_NO_THREADS) && defined(_LIBCPP_HAS_THREAD_API_PTHREAD)
+#  error _LIBCPP_HAS_THREAD_API_PTHREAD may only be defined when \
+         _LIBCPP_HAS_NO_THREADS is not defined.
+#endif
+
 #if defined(_LIBCPP_HAS_NO_MONOTONIC_CLOCK) && !defined(_LIBCPP_HAS_NO_THREADS)
 #  error _LIBCPP_HAS_NO_MONOTONIC_CLOCK may only be defined when \
          _LIBCPP_HAS_NO_THREADS is defined.
@@ -833,7 +884,20 @@ extern "C" void __sanitizer_annotate_contiguous_container(
 
 #ifndef _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
 #define _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
-#endif 
+#endif
+
+#if __cplusplus < 201103L
+#define _LIBCPP_CXX03_LANG
+#else
+#if defined(_LIBCPP_HAS_NO_VARIADIC_TEMPLATES) || defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
+#error Libc++ requires a feature complete C++11 compiler in C++11 or greater.
+#endif
+#endif
+
+#if (defined(_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS) && defined(__clang__) \
+      && __has_attribute(acquire_capability))
+#define _LIBCPP_HAS_THREAD_SAFETY_ANNOTATIONS
+#endif
 
 #endif // __cplusplus
 
diff --git a/include/__config_site.in b/include/__config_site.in
index ec64485289fa..6c2b7bb446d7 100644
--- a/include/__config_site.in
+++ b/include/__config_site.in
@@ -19,5 +19,6 @@
 #cmakedefine _LIBCPP_HAS_NO_MONOTONIC_CLOCK
 #cmakedefine _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS
 #cmakedefine _LIBCPP_HAS_MUSL_LIBC
+#cmakedefine _LIBCPP_HAS_THREAD_API_PTHREAD
 
 #endif // _LIBCPP_CONFIG_SITE
diff --git a/include/__functional_base b/include/__functional_base
index 52c535aa3ea1..1a08ea29deea 100644
--- a/include/__functional_base
+++ b/include/__functional_base
@@ -38,8 +38,6 @@ struct _LIBCPP_TYPE_VIS_ONLY binary_function
     typedef _Result result_type;
 };
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY hash;
-
 template <class _Tp>
 struct __has_result_type
 {
@@ -306,75 +304,19 @@ struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) const volatile>
 
 #endif // _LIBCPP_HAS_NO_VARIADICS
 
-// __invoke
-
-#ifndef _LIBCPP_HAS_NO_VARIADICS
-
-// bullets 1 and 2
-
-template <class _Fp, class _A0, class ..._Args,
-            class>
-inline _LIBCPP_INLINE_VISIBILITY
-auto
-__invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
-    -> decltype((_VSTD::forward<_A0>(__a0).*__f)(_VSTD::forward<_Args>(__args)...))
-{
-    return (_VSTD::forward<_A0>(__a0).*__f)(_VSTD::forward<_Args>(__args)...);
-}
-
-template <class _Fp, class _A0, class ..._Args,
-            class>
-inline _LIBCPP_INLINE_VISIBILITY
-auto
-__invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
-    -> decltype(((*_VSTD::forward<_A0>(__a0)).*__f)(_VSTD::forward<_Args>(__args)...))
-{
-    return ((*_VSTD::forward<_A0>(__a0)).*__f)(_VSTD::forward<_Args>(__args)...);
-}
-
-// bullets 3 and 4
+#ifndef _LIBCPP_CXX03_LANG
 
-template <class _Fp, class _A0,
-            class>
-inline _LIBCPP_INLINE_VISIBILITY
-auto
-__invoke(_Fp&& __f, _A0&& __a0)
-    -> decltype(_VSTD::forward<_A0>(__a0).*__f)
-{
-    return _VSTD::forward<_A0>(__a0).*__f;
-}
-
-template <class _Fp, class _A0,
-            class>
-inline _LIBCPP_INLINE_VISIBILITY
-auto
-__invoke(_Fp&& __f, _A0&& __a0)
-    -> decltype((*_VSTD::forward<_A0>(__a0)).*__f)
-{
-    return (*_VSTD::forward<_A0>(__a0)).*__f;
-}
-
-// bullet 5
-
-template <class _Fp, class ..._Args>
-inline _LIBCPP_INLINE_VISIBILITY
-auto
-__invoke(_Fp&& __f, _Args&& ...__args)
-    -> decltype(_VSTD::forward<_Fp>(__f)(_VSTD::forward<_Args>(__args)...))
-{
-    return _VSTD::forward<_Fp>(__f)(_VSTD::forward<_Args>(__args)...);
-}
 template <class _Tp, class ..._Args>
 struct __invoke_return
 {
     typedef decltype(__invoke(_VSTD::declval<_Tp>(), _VSTD::declval<_Args>()...)) type;
 };
 
-#else // _LIBCPP_HAS_NO_VARIADICS
+#else // defined(_LIBCPP_CXX03_LANG)
 
 #include <__functional_base_03>
 
-#endif  // _LIBCPP_HAS_NO_VARIADICS
+#endif  // !defined(_LIBCPP_CXX03_LANG)
 
 
 template <class _Ret>
@@ -577,10 +519,6 @@ public:
 #endif // _LIBCPP_HAS_NO_VARIADICS
 };
 
-template <class _Tp> struct __is_reference_wrapper_impl : public false_type {};
-template <class _Tp> struct __is_reference_wrapper_impl<reference_wrapper<_Tp> > : public true_type {};
-template <class _Tp> struct __is_reference_wrapper
-    : public __is_reference_wrapper_impl<typename remove_cv<_Tp>::type> {};
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
diff --git a/include/__hash_table b/include/__hash_table
index c7d1ef3d082f..08bc519ae17f 100644
--- a/include/__hash_table
+++ b/include/__hash_table
@@ -17,6 +17,7 @@
 #include <iterator>
 #include <algorithm>
 #include <cmath>
+#include <utility>
 
 #include <__undef_min_max>
 #include <__undef___deallocate>
@@ -29,6 +30,29 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+
+#ifndef _LIBCPP_CXX03_LANG
+template <class _Key, class _Tp>
+union __hash_value_type;
+#else
+template <class _Key, class _Tp>
+struct __hash_value_type;
+#endif
+
+#ifndef _LIBCPP_CXX03_LANG
+template <class _Tp>
+struct __is_hash_value_type_imp : false_type {};
+
+template <class _Key, class _Value>
+struct __is_hash_value_type_imp<__hash_value_type<_Key, _Value>> : true_type {};
+
+template <class ..._Args>
+struct __is_hash_value_type : false_type {};
+
+template <class _One>
+struct __is_hash_value_type<_One> : __is_hash_value_type_imp<typename __uncvref<_One>::type> {};
+#endif
+
 _LIBCPP_FUNC_VIS
 size_t __next_prime(size_t __n);
 
@@ -49,10 +73,10 @@ struct __hash_node
                  typename __rebind_pointer<_VoidPtr, __hash_node<_Tp, _VoidPtr> >::type
              >
 {
-    typedef _Tp value_type;
+    typedef _Tp __node_value_type;
 
     size_t     __hash_;
-    value_type __value_;
+    __node_value_type __value_;
 };
 
 inline _LIBCPP_INLINE_VISIBILITY
@@ -66,7 +90,8 @@ inline _LIBCPP_INLINE_VISIBILITY
 size_t
 __constrain_hash(size_t __h, size_t __bc)
 {
-    return !(__bc & (__bc - 1)) ? __h & (__bc - 1) : __h % __bc;
+    return !(__bc & (__bc - 1)) ? __h & (__bc - 1) :
+        (__h < __bc ? __h : __h % __bc);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
@@ -76,24 +101,173 @@ __next_hash_pow2(size_t __n)
     return size_t(1) << (std::numeric_limits<size_t>::digits - __clz(__n-1));
 }
 
+
 template <class _Tp, class _Hash, class _Equal, class _Alloc> class __hash_table;
+
+template <class _NodePtr>      class _LIBCPP_TYPE_VIS_ONLY __hash_iterator;
 template <class _ConstNodePtr> class _LIBCPP_TYPE_VIS_ONLY __hash_const_iterator;
+template <class _NodePtr>      class _LIBCPP_TYPE_VIS_ONLY __hash_local_iterator;
+template <class _ConstNodePtr> class _LIBCPP_TYPE_VIS_ONLY __hash_const_local_iterator;
 template <class _HashIterator> class _LIBCPP_TYPE_VIS_ONLY __hash_map_iterator;
 template <class _HashIterator> class _LIBCPP_TYPE_VIS_ONLY __hash_map_const_iterator;
 
+template <class _Tp>
+struct __hash_key_value_types {
+  static_assert(!is_reference<_Tp>::value && !is_const<_Tp>::value, "");
+  typedef _Tp key_type;
+  typedef _Tp __node_value_type;
+  typedef _Tp __container_value_type;
+  static const bool __is_map = false;
+
+  _LIBCPP_INLINE_VISIBILITY
+  static key_type const& __get_key(_Tp const& __v) {
+    return __v;
+  }
+  _LIBCPP_INLINE_VISIBILITY
+  static __container_value_type const& __get_value(__node_value_type const& __v) {
+    return __v;
+  }
+  _LIBCPP_INLINE_VISIBILITY
+  static __container_value_type* __get_ptr(__node_value_type& __n) {
+    return _VSTD::addressof(__n);
+  }
+#ifndef _LIBCPP_CXX03_LANG
+  _LIBCPP_INLINE_VISIBILITY
+  static  __container_value_type&& __move(__node_value_type& __v) {
+    return _VSTD::move(__v);
+  }
+#endif
+};
+
+template <class _Key, class _Tp>
+struct __hash_key_value_types<__hash_value_type<_Key, _Tp> > {
+  typedef _Key                                         key_type;
+  typedef _Tp                                          mapped_type;
+  typedef __hash_value_type<_Key, _Tp>                 __node_value_type;
+  typedef pair<const _Key, _Tp>                        __container_value_type;
+  typedef pair<_Key, _Tp>                              __nc_value_type;
+  typedef __container_value_type                       __map_value_type;
+  static const bool __is_map = true;
+
+  _LIBCPP_INLINE_VISIBILITY
+  static key_type const& __get_key(__container_value_type const& __v) {
+    return __v.first;
+  }
+
+  template <class _Up>
+  _LIBCPP_INLINE_VISIBILITY
+  static typename enable_if<__is_same_uncvref<_Up, __node_value_type>::value,
+      __container_value_type const&>::type
+  __get_value(_Up& __t) {
+    return __t.__cc;
+  }
+
+  template <class _Up>
+  _LIBCPP_INLINE_VISIBILITY
+  static typename enable_if<__is_same_uncvref<_Up, __container_value_type>::value,
+      __container_value_type const&>::type
+  __get_value(_Up& __t) {
+    return __t;
+  }
+
+  _LIBCPP_INLINE_VISIBILITY
+  static __container_value_type* __get_ptr(__node_value_type& __n) {
+    return _VSTD::addressof(__n.__cc);
+  }
+#ifndef _LIBCPP_CXX03_LANG
+  _LIBCPP_INLINE_VISIBILITY
+  static __nc_value_type&& __move(__node_value_type& __v) {
+    return _VSTD::move(__v.__nc);
+  }
+#endif
+
+};
+
+template <class _Tp, class _AllocPtr, class _KVTypes = __hash_key_value_types<_Tp>,
+          bool = _KVTypes::__is_map>
+struct __hash_map_pointer_types {};
+
+template <class _Tp, class _AllocPtr, class _KVTypes>
+struct __hash_map_pointer_types<_Tp, _AllocPtr, _KVTypes, true> {
+  typedef typename _KVTypes::__map_value_type   _Mv;
+  typedef typename __rebind_pointer<_AllocPtr, _Mv>::type
+                                                       __map_value_type_pointer;
+  typedef typename __rebind_pointer<_AllocPtr, const _Mv>::type
+                                                 __const_map_value_type_pointer;
+};
+
+template <class _NodePtr, class _NodeT = typename pointer_traits<_NodePtr>::element_type>
+struct __hash_node_types;
+
+template <class _NodePtr, class _Tp, class _VoidPtr>
+struct __hash_node_types<_NodePtr, __hash_node<_Tp, _VoidPtr> >
+    : public __hash_key_value_types<_Tp>, __hash_map_pointer_types<_Tp, _VoidPtr>
+
+{
+  typedef __hash_key_value_types<_Tp>           __base;
+
+public:
+  typedef ptrdiff_t difference_type;
+  typedef size_t size_type;
+
+  typedef typename __rebind_pointer<_NodePtr, void>::type       __void_pointer;
+
+  typedef typename pointer_traits<_NodePtr>::element_type       __node_type;
+  typedef _NodePtr                                              __node_pointer;
+
+  typedef __hash_node_base<__node_pointer>                      __node_base_type;
+  typedef typename __rebind_pointer<_NodePtr, __node_base_type>::type
+                                                             __node_base_pointer;
+
+  typedef _Tp                                                 __node_value_type;
+  typedef typename __rebind_pointer<_VoidPtr, __node_value_type>::type
+                                                      __node_value_type_pointer;
+  typedef typename __rebind_pointer<_VoidPtr, const __node_value_type>::type
+                                                __const_node_value_type_pointer;
+private:
+    static_assert(!is_const<__node_type>::value,
+                "_NodePtr should never be a pointer to const");
+    static_assert((is_same<typename pointer_traits<_VoidPtr>::element_type, void>::value),
+                  "_VoidPtr does not point to unqualified void type");
+    static_assert((is_same<typename __rebind_pointer<_VoidPtr, __node_type>::type,
+                          _NodePtr>::value), "_VoidPtr does not rebind to _NodePtr.");
+};
+
+
+
+template <class _HashIterator>
+struct __hash_node_types_from_iterator;
+template <class _NodePtr>
+struct __hash_node_types_from_iterator<__hash_iterator<_NodePtr> > : __hash_node_types<_NodePtr> {};
+template <class _NodePtr>
+struct __hash_node_types_from_iterator<__hash_const_iterator<_NodePtr> > : __hash_node_types<_NodePtr> {};
+template <class _NodePtr>
+struct __hash_node_types_from_iterator<__hash_local_iterator<_NodePtr> > : __hash_node_types<_NodePtr> {};
+template <class _NodePtr>
+struct __hash_node_types_from_iterator<__hash_const_local_iterator<_NodePtr> > : __hash_node_types<_NodePtr> {};
+
+
+template <class _NodeValueTp, class _VoidPtr>
+struct __make_hash_node_types {
+  typedef __hash_node<_NodeValueTp, _VoidPtr> _NodeTp;
+  typedef typename __rebind_pointer<_VoidPtr, _NodeTp>::type _NodePtr;
+  typedef __hash_node_types<_NodePtr> type;
+};
+
 template <class _NodePtr>
 class _LIBCPP_TYPE_VIS_ONLY __hash_iterator
 {
-    typedef _NodePtr __node_pointer;
+    typedef __hash_node_types<_NodePtr> _NodeTypes;
+    typedef _NodePtr                    __node_pointer;
 
     __node_pointer            __node_;
 
 public:
-    typedef forward_iterator_tag                         iterator_category;
-    typedef typename pointer_traits<__node_pointer>::element_type::value_type value_type;
-    typedef typename pointer_traits<__node_pointer>::difference_type difference_type;
-    typedef value_type&                                  reference;
-    typedef typename __rebind_pointer<__node_pointer, value_type>::type pointer;
+    typedef forward_iterator_tag                           iterator_category;
+    typedef typename _NodeTypes::__node_value_type         value_type;
+    typedef typename _NodeTypes::difference_type           difference_type;
+    typedef value_type&                                    reference;
+    typedef typename _NodeTypes::__node_value_type_pointer pointer;
 
     _LIBCPP_INLINE_VISIBILITY __hash_iterator() _NOEXCEPT
 #if _LIBCPP_STD_VER > 11
@@ -202,25 +376,24 @@ private:
     template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY unordered_multimap;
 };
 
-template <class _ConstNodePtr>
+template <class _NodePtr>
 class _LIBCPP_TYPE_VIS_ONLY __hash_const_iterator
 {
-    typedef _ConstNodePtr __node_pointer;
-
-    __node_pointer         __node_;
+    static_assert(!is_const<typename pointer_traits<_NodePtr>::element_type>::value, "");
+    typedef __hash_node_types<_NodePtr> _NodeTypes;
+    typedef _NodePtr __node_pointer;
 
-    typedef typename remove_const<
-        typename pointer_traits<__node_pointer>::element_type
-                                 >::type __node;
+    __node_pointer __node_;
 
 public:
-    typedef forward_iterator_tag                       iterator_category;
-    typedef typename __node::value_type                value_type;
-    typedef typename pointer_traits<__node_pointer>::difference_type difference_type;
-    typedef const value_type&                          reference;
-    typedef typename __rebind_pointer<__node_pointer, const value_type>::type pointer;
-    typedef typename __rebind_pointer<__node_pointer, __node>::type __non_const_node_pointer;
-    typedef __hash_iterator<__non_const_node_pointer> __non_const_iterator;
+    typedef __hash_iterator<_NodePtr> __non_const_iterator;
+
+    typedef forward_iterator_tag                                 iterator_category;
+    typedef typename _NodeTypes::__node_value_type               value_type;
+    typedef typename _NodeTypes::difference_type                 difference_type;
+    typedef const value_type&                                    reference;
+    typedef typename _NodeTypes::__const_node_value_type_pointer pointer;
+
 
     _LIBCPP_INLINE_VISIBILITY __hash_const_iterator() _NOEXCEPT
 #if _LIBCPP_STD_VER > 11
@@ -336,24 +509,22 @@ private:
     template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY unordered_multimap;
 };
 
-template <class _ConstNodePtr> class _LIBCPP_TYPE_VIS_ONLY __hash_const_local_iterator;
-
 template <class _NodePtr>
 class _LIBCPP_TYPE_VIS_ONLY __hash_local_iterator
 {
-    typedef _NodePtr __node_pointer;
+    typedef __hash_node_types<_NodePtr> _NodeTypes;
+    typedef _NodePtr                    __node_pointer;
 
     __node_pointer         __node_;
     size_t                 __bucket_;
     size_t                 __bucket_count_;
 
-    typedef pointer_traits<__node_pointer>          __pointer_traits;
 public:
     typedef forward_iterator_tag                                iterator_category;
-    typedef typename __pointer_traits::element_type::value_type value_type;
-    typedef typename __pointer_traits::difference_type          difference_type;
+    typedef typename _NodeTypes::__node_value_type              value_type;
+    typedef typename _NodeTypes::difference_type                difference_type;
     typedef value_type&                                         reference;
-    typedef typename __rebind_pointer<__node_pointer, value_type>::type pointer;
+    typedef typename _NodeTypes::__node_value_type_pointer      pointer;
 
     _LIBCPP_INLINE_VISIBILITY __hash_local_iterator() _NOEXCEPT
     {
@@ -476,7 +647,8 @@ private:
 template <class _ConstNodePtr>
 class _LIBCPP_TYPE_VIS_ONLY __hash_const_local_iterator
 {
-    typedef _ConstNodePtr __node_pointer;
+    typedef __hash_node_types<_ConstNodePtr> _NodeTypes;
+    typedef _ConstNodePtr                    __node_pointer;
 
     __node_pointer         __node_;
     size_t                 __bucket_;
@@ -487,18 +659,15 @@ class _LIBCPP_TYPE_VIS_ONLY __hash_const_local_iterator
     typedef typename remove_const<__node>::type     __non_const_node;
     typedef typename __rebind_pointer<__node_pointer, __non_const_node>::type
         __non_const_node_pointer;
-
+public:
     typedef __hash_local_iterator<__non_const_node_pointer>
                                                     __non_const_iterator;
-public:
-    typedef forward_iterator_tag                       iterator_category;
-    typedef typename remove_const<
-                        typename __pointer_traits::element_type::value_type
-                     >::type                           value_type;
-    typedef typename __pointer_traits::difference_type difference_type;
-    typedef const value_type&                          reference;
-    typedef typename __rebind_pointer<__node_pointer, const value_type>::type
-        pointer;
+
+    typedef forward_iterator_tag                                 iterator_category;
+    typedef typename _NodeTypes::__node_value_type               value_type;
+    typedef typename _NodeTypes::difference_type                 difference_type;
+    typedef const value_type&                                    reference;
+    typedef typename _NodeTypes::__const_node_value_type_pointer pointer;
 
 
     _LIBCPP_INLINE_VISIBILITY __hash_const_local_iterator() _NOEXCEPT
@@ -686,10 +855,11 @@ class __hash_node_destructor
 {
     typedef _Alloc                                          allocator_type;
     typedef allocator_traits<allocator_type>                __alloc_traits;
-    typedef typename __alloc_traits::value_type::value_type value_type;
+
 public:
     typedef typename __alloc_traits::pointer                pointer;
 private:
+    typedef __hash_node_types<pointer> _NodeTypes;
 
     allocator_type& __na_;
 
@@ -709,7 +879,7 @@ public:
     void operator()(pointer __p) _NOEXCEPT
     {
         if (__value_constructed)
-            __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_));
+            __alloc_traits::destroy(__na_, _NodeTypes::__get_ptr(__p->__value_));
         if (__p)
             __alloc_traits::deallocate(__na_, __p, 1);
     }
@@ -728,23 +898,47 @@ public:
 
 private:
     typedef allocator_traits<allocator_type> __alloc_traits;
+    typedef typename
+      __make_hash_node_types<value_type, typename __alloc_traits::void_pointer>::type
+                                                                     _NodeTypes;
 public:
+
+    typedef typename _NodeTypes::__node_value_type           __node_value_type;
+    typedef typename _NodeTypes::__container_value_type      __container_value_type;
+    typedef typename _NodeTypes::key_type                    key_type;
     typedef value_type&                              reference;
     typedef const value_type&                        const_reference;
     typedef typename __alloc_traits::pointer         pointer;
     typedef typename __alloc_traits::const_pointer   const_pointer;
+#ifndef _LIBCPP_ABI_FIX_UNORDERED_CONTAINER_SIZE_TYPE
     typedef typename __alloc_traits::size_type       size_type;
-    typedef typename __alloc_traits::difference_type difference_type;
+#else
+    typedef typename _NodeTypes::size_type           size_type;
+#endif
+    typedef typename _NodeTypes::difference_type     difference_type;
 public:
     // Create __node
-    typedef __hash_node<value_type, typename __alloc_traits::void_pointer> __node;
+
+    typedef typename _NodeTypes::__node_type __node;
     typedef typename __rebind_alloc_helper<__alloc_traits, __node>::type __node_allocator;
     typedef allocator_traits<__node_allocator>       __node_traits;
-    typedef typename __node_traits::pointer          __node_pointer;
-    typedef typename __node_traits::pointer          __node_const_pointer;
-    typedef __hash_node_base<__node_pointer>         __first_node;
-    typedef typename __rebind_pointer<__node_pointer, __first_node>::type
-        __node_base_pointer;
+    typedef typename _NodeTypes::__void_pointer      __void_pointer;
+    typedef typename _NodeTypes::__node_pointer      __node_pointer;
+    typedef typename _NodeTypes::__node_pointer      __node_const_pointer;
+    typedef typename _NodeTypes::__node_base_type    __first_node;
+    typedef typename _NodeTypes::__node_base_pointer __node_base_pointer;
+
+private:
+    // check for sane allocator pointer rebinding semantics. Rebinding the
+    // allocator for a new pointer type should be exactly the same as rebinding
+    // the pointer using 'pointer_traits'.
+    static_assert((is_same<__node_pointer, typename __node_traits::pointer>::value),
+                  "Allocator does not rebind pointers in a sane manner.");
+    typedef typename __rebind_alloc_helper<__node_traits, __first_node>::type
+        __node_base_allocator;
+    typedef allocator_traits<__node_base_allocator> __node_base_traits;
+    static_assert((is_same<__node_base_pointer, typename __node_base_traits::pointer>::value),
+                 "Allocator does not rebind pointers in a sane manner.");
 
 private:
 
@@ -755,10 +949,10 @@ private:
     typedef typename __bucket_list_deleter::pointer __node_pointer_pointer;
 
     // --- Member data begin ---
-    __bucket_list                                     __bucket_list_;
-    __compressed_pair<__first_node, __node_allocator> __p1_;
-    __compressed_pair<size_type, hasher>              __p2_;
-    __compressed_pair<float, key_equal>               __p3_;
+    __bucket_list                                         __bucket_list_;
+    __compressed_pair<__first_node, __node_allocator>     __p1_;
+    __compressed_pair<size_type, hasher>                  __p2_;
+    __compressed_pair<float, key_equal>                   __p3_;
     // --- Member data end ---
 
     _LIBCPP_INLINE_VISIBILITY
@@ -809,7 +1003,7 @@ public:
     explicit __hash_table(const allocator_type& __a);
     __hash_table(const __hash_table& __u);
     __hash_table(const __hash_table& __u, const allocator_type& __a);
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifndef _LIBCPP_CXX03_LANG
     __hash_table(__hash_table&& __u)
         _NOEXCEPT_(
             is_nothrow_move_constructible<__bucket_list>::value &&
@@ -818,11 +1012,11 @@ public:
             is_nothrow_move_constructible<hasher>::value &&
             is_nothrow_move_constructible<key_equal>::value);
     __hash_table(__hash_table&& __u, const allocator_type& __a);
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif  // _LIBCPP_CXX03_LANG
     ~__hash_table();
 
     __hash_table& operator=(const __hash_table& __u);
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     __hash_table& operator=(__hash_table&& __u)
         _NOEXCEPT_(
@@ -848,41 +1042,103 @@ public:
     iterator             __node_insert_multi(const_iterator __p,
                                              __node_pointer __nd);
 
-#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
-    template <class... _Args>
-        pair<iterator, bool> __emplace_unique(_Args&&... __args);
-    template <class... _Args>
-        iterator __emplace_multi(_Args&&... __args);
+#ifndef _LIBCPP_CXX03_LANG
+    template <class _Key, class ..._Args>
+    _LIBCPP_INLINE_VISIBILITY
+    pair<iterator, bool> __emplace_unique_key_args(_Key const& __k, _Args&&... __args);
+
     template <class... _Args>
-        iterator __emplace_hint_multi(const_iterator __p, _Args&&... __args);
-#endif  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
+    _LIBCPP_INLINE_VISIBILITY
+    pair<iterator, bool> __emplace_unique_impl(_Args&&... __args);
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    template <class _ValueTp>
+    template <class _Pp>
     _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, bool> __insert_unique_value(_ValueTp&& __x);
-#else
+    pair<iterator, bool> __emplace_unique(_Pp&& __x) {
+      return __emplace_unique_extract_key(_VSTD::forward<_Pp>(__x),
+                                          __can_extract_key<_Pp, key_type>());
+    }
+
+    template <class _First, class _Second>
     _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, bool> __insert_unique_value(const value_type& __x);
-#endif
+    typename enable_if<
+        __can_extract_map_key<_First, key_type, __container_value_type>::value,
+        pair<iterator, bool>
+    >::type __emplace_unique(_First&& __f, _Second&& __s) {
+        return __emplace_unique_key_args(__f, _VSTD::forward<_First>(__f),
+                                              _VSTD::forward<_Second>(__s));
+    }
 
-    pair<iterator, bool> __insert_unique(const value_type& __x);
+    template <class... _Args>
+    _LIBCPP_INLINE_VISIBILITY
+    pair<iterator, bool> __emplace_unique(_Args&&... __args) {
+      return __emplace_unique_impl(_VSTD::forward<_Args>(__args)...);
+    }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    pair<iterator, bool> __insert_unique(value_type&& __x);
     template <class _Pp>
-    pair<iterator, bool> __insert_unique(_Pp&& __x);
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
+    pair<iterator, bool>
+    __emplace_unique_extract_key(_Pp&& __x, __extract_key_fail_tag) {
+      return __emplace_unique_impl(_VSTD::forward<_Pp>(__x));
+    }
+    template <class _Pp>
+    _LIBCPP_INLINE_VISIBILITY
+    pair<iterator, bool>
+    __emplace_unique_extract_key(_Pp&& __x, __extract_key_self_tag) {
+      return __emplace_unique_key_args(__x, _VSTD::forward<_Pp>(__x));
+    }
+    template <class _Pp>
+    _LIBCPP_INLINE_VISIBILITY
+    pair<iterator, bool>
+    __emplace_unique_extract_key(_Pp&& __x, __extract_key_first_tag) {
+      return __emplace_unique_key_args(__x.first, _VSTD::forward<_Pp>(__x));
+    }
+
+    template <class... _Args>
+    _LIBCPP_INLINE_VISIBILITY
+    iterator __emplace_multi(_Args&&... __args);
+    template <class... _Args>
+    _LIBCPP_INLINE_VISIBILITY
+    iterator __emplace_hint_multi(const_iterator __p, _Args&&... __args);
+
+
+    _LIBCPP_INLINE_VISIBILITY
+    pair<iterator, bool>
+    __insert_unique(__container_value_type&& __x) {
+      return __emplace_unique_key_args(_NodeTypes::__get_key(__x), _VSTD::move(__x));
+    }
+
+    template <class _Pp, class = typename enable_if<
+            !__is_same_uncvref<_Pp, __container_value_type>::value
+        >::type>
+    _LIBCPP_INLINE_VISIBILITY
+    pair<iterator, bool> __insert_unique(_Pp&& __x) {
+      return __emplace_unique(_VSTD::forward<_Pp>(__x));
+    }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template <class _Pp>
-        iterator __insert_multi(_Pp&& __x);
+    _LIBCPP_INLINE_VISIBILITY
+    iterator __insert_multi(_Pp&& __x) {
+      return __emplace_multi(_VSTD::forward<_Pp>(__x));
+    }
+
     template <class _Pp>
-        iterator __insert_multi(const_iterator __p, _Pp&& __x);
-#else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    iterator __insert_multi(const value_type& __x);
-    iterator __insert_multi(const_iterator __p, const value_type& __x);
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
+    iterator __insert_multi(const_iterator __p, _Pp&& __x) {
+        return __emplace_hint_multi(__p, _VSTD::forward<_Pp>(__x));
+    }
+
+#else  // !defined(_LIBCPP_CXX03_LANG)
+    template <class _Key, class _Args>
+    pair<iterator, bool> __emplace_unique_key_args(_Key const&, _Args& __args);
+
+    iterator __insert_multi(const __container_value_type& __x);
+    iterator __insert_multi(const_iterator __p, const __container_value_type& __x);
+#endif
+
+    _LIBCPP_INLINE_VISIBILITY
+    pair<iterator, bool> __insert_unique(const __container_value_type& __x) {
+        return __emplace_unique_key_args(_NodeTypes::__get_key(__x), __x);
+    }
 
     void clear() _NOEXCEPT;
     void rehash(size_type __n);
@@ -1042,16 +1298,17 @@ public:
 private:
     void __rehash(size_type __n);
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#ifndef _LIBCPP_HAS_NO_VARIADICS
+#ifndef _LIBCPP_CXX03_LANG
     template <class ..._Args>
-        __node_holder __construct_node(_Args&& ...__args);
-#endif  // _LIBCPP_HAS_NO_VARIADICS
-    __node_holder __construct_node(value_type&& __v, size_t __hash);
-#else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    __node_holder __construct_node(const value_type& __v);
+    __node_holder __construct_node(_Args&& ...__args);
+
+    template <class _First, class ..._Rest>
+    __node_holder __construct_node_hash(size_t __hash, _First&& __f, _Rest&&... __rest);
+#else // _LIBCPP_CXX03_LANG
+    __node_holder __construct_node(const __container_value_type& __v);
+    __node_holder __construct_node_hash(size_t __hash, const __container_value_type& __v);
 #endif
-    __node_holder __construct_node(const value_type& __v, size_t __hash);
+
 
     _LIBCPP_INLINE_VISIBILITY
     void __copy_assign_alloc(const __hash_table& __u)
@@ -1061,6 +1318,7 @@ private:
     _LIBCPP_INLINE_VISIBILITY
         void __copy_assign_alloc(const __hash_table&, false_type) {}
 
+#ifndef _LIBCPP_CXX03_LANG
     void __move_assign(__hash_table& __u, false_type);
     void __move_assign(__hash_table& __u, true_type)
         _NOEXCEPT_(
@@ -1087,6 +1345,7 @@ private:
     }
     _LIBCPP_INLINE_VISIBILITY
         void __move_assign_alloc(__hash_table&, false_type) _NOEXCEPT {}
+#endif // _LIBCPP_CXX03_LANG
 
     void __deallocate(__node_pointer __np) _NOEXCEPT;
     __node_pointer __detach() _NOEXCEPT;
@@ -1163,7 +1422,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const __hash_table& __u,
 {
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(__hash_table&& __u)
@@ -1212,11 +1471,15 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(__hash_table&& __u,
     }
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif  // _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::~__hash_table()
 {
+    static_assert((is_copy_constructible<key_equal>::value),
+                 "Predicate must be copy-constructible.");
+    static_assert((is_copy_constructible<hasher>::value),
+                 "Hasher must be copy-constructible.");
     __deallocate(__p1_.first().__next_);
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__erase_c(this);
@@ -1277,7 +1540,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__deallocate(__node_pointer __np)
         }
         __get_db()->unlock();
 #endif
-        __node_traits::destroy(__na, _VSTD::addressof(__np->__value_));
+        __node_traits::destroy(__na, _NodeTypes::__get_ptr(__np->__value_));
         __node_traits::deallocate(__na, __np, 1);
         __np = __next;
     }
@@ -1296,7 +1559,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__detach() _NOEXCEPT
     return __cache;
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 void
@@ -1369,8 +1632,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__move_assign(
         const_iterator __i = __u.begin();
         while (__u.size() != 0)
         {
-            __node_holder __h =
-                    __construct_node(_VSTD::move(__u.remove(__i++)->__value_));
+            __node_holder __h = __construct_node(_NodeTypes::__move(__u.remove(__i++)->__value_));
             __node_insert_multi(__h.get());
             __h.release();
         }
@@ -1392,7 +1654,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::operator=(__hash_table&& __u)
     return *this;
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif  // _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class _InputIterator>
@@ -1400,6 +1662,11 @@ void
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__assign_unique(_InputIterator __first,
                                                           _InputIterator __last)
 {
+    typedef iterator_traits<_InputIterator> _ITraits;
+    typedef typename _ITraits::value_type _ItValueType;
+    static_assert((is_same<_ItValueType, __container_value_type>::value),
+                  "__assign_unique may only be called with the containers value type");
+
     if (bucket_count() != 0)
     {
         __node_pointer __cache = __detach();
@@ -1434,6 +1701,12 @@ void
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__assign_multi(_InputIterator __first,
                                                          _InputIterator __last)
 {
+    typedef iterator_traits<_InputIterator> _ITraits;
+    typedef typename _ITraits::value_type _ItValueType;
+    static_assert((is_same<_ItValueType, __container_value_type>::value ||
+                  is_same<_ItValueType, __node_value_type>::value),
+                  "__assign_multi may only be called with the containers value type"
+                  " or the nodes value type");
     if (bucket_count() != 0)
     {
         __node_pointer __cache = __detach();
@@ -1459,7 +1732,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__assign_multi(_InputIterator __first,
         __deallocate(__cache);
     }
     for (; __first != __last; ++__first)
-        __insert_multi(*__first);
+        __insert_multi(_NodeTypes::__get_value(*__first));
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
@@ -1685,31 +1958,24 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi(
     return __node_insert_multi(__cp);
 }
 
-template <class _Tp, class _Hash, class _Equal, class _Alloc>
-pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator, bool>
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_unique(const value_type& __x)
-{
-    return __insert_unique_value(__x);
-}
 
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifndef _LIBCPP_CXX03_LANG
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-template <class _ValueTp>
+template <class _Key, class ..._Args>
 _LIBCPP_INLINE_VISIBILITY
 pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator, bool>
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_unique_value(_ValueTp&& __x)
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_unique_key_args(_Key const& __k, _Args&&... __args)
 #else
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
+template <class _Key, class _Args>
 _LIBCPP_INLINE_VISIBILITY
 pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator, bool>
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_unique_value(const value_type& __x)
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_unique_key_args(_Key const& __k, _Args& __args)
 #endif
 {
-#if defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
-    typedef const value_type& _ValueTp;
-#endif
-    size_t __hash = hash_function()(__x);
+
+    size_t __hash = hash_function()(__k);
     size_type __bc = bucket_count();
     bool __inserted = false;
     __node_pointer __nd;
@@ -1724,13 +1990,17 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_unique_value(const value_type
                                        __constrain_hash(__nd->__hash_, __bc) == __chash;
                                                            __nd = __nd->__next_)
             {
-                if (key_eq()(__nd->__value_, __x))
+                if (key_eq()(__nd->__value_, __k))
                     goto __done;
             }
         }
     }
     {
-        __node_holder __h = __construct_node(_VSTD::forward<_ValueTp>(__x), __hash);
+#ifndef _LIBCPP_CXX03_LANG
+        __node_holder __h = __construct_node_hash(__hash, _VSTD::forward<_Args>(__args)...);
+#else
+        __node_holder __h = __construct_node_hash(__hash, __args);
+#endif
         if (size()+1 > __bc * max_load_factor() || __bc == 0)
         {
             rehash(_VSTD::max<size_type>(2 * __bc + !__is_hash_power2(__bc),
@@ -1742,7 +2012,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_unique_value(const value_type
         __node_pointer __pn = __bucket_list_[__chash];
         if (__pn == nullptr)
         {
-            __pn = static_cast<__node_pointer>(pointer_traits<__node_base_pointer>::pointer_to(__p1_.first()));
+            __pn = static_cast<__node_pointer>(static_cast<__void_pointer>(pointer_traits<__node_base_pointer>::pointer_to(__p1_.first())));
             __h->__next_ = __pn->__next_;
             __pn->__next_ = __h.get();
             // fix up __bucket_list_
@@ -1768,13 +2038,12 @@ __done:
 #endif
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#ifndef _LIBCPP_HAS_NO_VARIADICS
+#ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class... _Args>
 pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator, bool>
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_unique(_Args&&... __args)
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_unique_impl(_Args&&... __args)
 {
     __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
     pair<iterator, bool> __r = __node_insert_unique(__h.get());
@@ -1811,64 +2080,11 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_hint_multi(
     return __r;
 }
 
-#endif  // _LIBCPP_HAS_NO_VARIADICS
+#else // _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator, bool>
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_unique(value_type&& __x)
-{
-    return __insert_unique_value(_VSTD::move(__x));
-}
-
-template <class _Tp, class _Hash, class _Equal, class _Alloc>
-template <class _Pp>
-pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator, bool>
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_unique(_Pp&& __x)
-{
-    __node_holder __h = __construct_node(_VSTD::forward<_Pp>(__x));
-    pair<iterator, bool> __r = __node_insert_unique(__h.get());
-    if (__r.second)
-        __h.release();
-    return __r;
-}
-
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
-template <class _Tp, class _Hash, class _Equal, class _Alloc>
-template <class _Pp>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_multi(_Pp&& __x)
-{
-    __node_holder __h = __construct_node(_VSTD::forward<_Pp>(__x));
-    iterator __r = __node_insert_multi(__h.get());
-    __h.release();
-    return __r;
-}
-
-template <class _Tp, class _Hash, class _Equal, class _Alloc>
-template <class _Pp>
-typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_multi(const_iterator __p,
-                                                         _Pp&& __x)
-{
-#if _LIBCPP_DEBUG_LEVEL >= 2
-    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
-        "unordered container::insert(const_iterator, rvalue) called with an iterator not"
-        " referring to this unordered container");
-#endif
-    __node_holder __h = __construct_node(_VSTD::forward<_Pp>(__x));
-    iterator __r = __node_insert_multi(__p, __h.get());
-    __h.release();
-    return __r;
-}
-
-#else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
-template <class _Tp, class _Hash, class _Equal, class _Alloc>
-typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_multi(const value_type& __x)
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_multi(const __container_value_type& __x)
 {
     __node_holder __h = __construct_node(__x);
     iterator __r = __node_insert_multi(__h.get());
@@ -1879,7 +2095,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_multi(const value_type& __x)
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_multi(const_iterator __p,
-                                                         const value_type& __x)
+                                                         const __container_value_type& __x)
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
@@ -1892,7 +2108,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_multi(const_iterator __p,
     return __r;
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif  // _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 void
@@ -1986,10 +2202,11 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::find(const _Key& __k)
         if (__nd != nullptr)
         {
             for (__nd = __nd->__next_; __nd != nullptr &&
-                                       __constrain_hash(__nd->__hash_, __bc) == __chash;
+                (__nd->__hash_ == __hash
+                  || __constrain_hash(__nd->__hash_, __bc) == __chash);
                                                            __nd = __nd->__next_)
             {
-                if (key_eq()(__nd->__value_, __k))
+                if ((__nd->__hash_ == __hash) && key_eq()(__nd->__value_, __k))
 #if _LIBCPP_DEBUG_LEVEL >= 2
                     return iterator(__nd, this);
 #else
@@ -2015,10 +2232,10 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::find(const _Key& __k) const
         if (__nd != nullptr)
         {
             for (__nd = __nd->__next_; __nd != nullptr &&
-                                           __constrain_hash(__nd->__hash_, __bc) == __chash;
+                (__hash == __nd->__hash_ || __constrain_hash(__nd->__hash_, __bc) == __chash);
                                                            __nd = __nd->__next_)
             {
-                if (key_eq()(__nd->__value_, __k))
+                if ((__nd->__hash_ == __hash) && key_eq()(__nd->__value_, __k))
 #if _LIBCPP_DEBUG_LEVEL >= 2
                     return const_iterator(__nd, this);
 #else
@@ -2031,70 +2248,74 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::find(const _Key& __k) const
     return end();
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#ifndef _LIBCPP_HAS_NO_VARIADICS
+#ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class ..._Args>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_holder
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(_Args&& ...__args)
 {
+    static_assert(!__is_hash_value_type<_Args...>::value,
+                  "Construct cannot be called with a hash value type");
     __node_allocator& __na = __node_alloc();
     __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
-    __node_traits::construct(__na, _VSTD::addressof(__h->__value_), _VSTD::forward<_Args>(__args)...);
+    __node_traits::construct(__na, _NodeTypes::__get_ptr(__h->__value_), _VSTD::forward<_Args>(__args)...);
     __h.get_deleter().__value_constructed = true;
     __h->__hash_ = hash_function()(__h->__value_);
     __h->__next_ = nullptr;
     return __h;
 }
 
-#endif  // _LIBCPP_HAS_NO_VARIADICS
-
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
+template <class _First, class ..._Rest>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_holder
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(value_type&& __v,
-                                                           size_t __hash)
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node_hash(
+    size_t __hash, _First&& __f, _Rest&& ...__rest)
 {
+    static_assert(!__is_hash_value_type<_First, _Rest...>::value,
+                  "Construct cannot be called with a hash value type");
     __node_allocator& __na = __node_alloc();
     __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
-    __node_traits::construct(__na, _VSTD::addressof(__h->__value_), _VSTD::move(__v));
+    __node_traits::construct(__na, _NodeTypes::__get_ptr(__h->__value_),
+                             _VSTD::forward<_First>(__f),
+                             _VSTD::forward<_Rest>(__rest)...);
     __h.get_deleter().__value_constructed = true;
     __h->__hash_ = __hash;
     __h->__next_ = nullptr;
     return __h;
 }
 
-#else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#else  // _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_holder
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(const value_type& __v)
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(const __container_value_type& __v)
 {
     __node_allocator& __na = __node_alloc();
     __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
-    __node_traits::construct(__na, _VSTD::addressof(__h->__value_), __v);
+    __node_traits::construct(__na, _NodeTypes::__get_ptr(__h->__value_), __v);
     __h.get_deleter().__value_constructed = true;
     __h->__hash_ = hash_function()(__h->__value_);
     __h->__next_ = nullptr;
     return _LIBCPP_EXPLICIT_MOVE(__h);  // explicitly moved for C++03
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_holder
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(const value_type& __v,
-                                                           size_t __hash)
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node_hash(size_t __hash,
+                                                                const __container_value_type& __v)
 {
     __node_allocator& __na = __node_alloc();
     __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
-    __node_traits::construct(__na, _VSTD::addressof(__h->__value_), __v);
+    __node_traits::construct(__na, _NodeTypes::__get_ptr(__h->__value_), __v);
     __h.get_deleter().__value_constructed = true;
     __h->__hash_ = __hash;
     __h->__next_ = nullptr;
     return _LIBCPP_EXPLICIT_MOVE(__h);  // explicitly moved for C++03
 }
 
+#endif  // _LIBCPP_CXX03_LANG
+
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::erase(const_iterator __p)
diff --git a/include/__mutex_base b/include/__mutex_base
index b019b4760d18..38a76ac6f2ec 100644
--- a/include/__mutex_base
+++ b/include/__mutex_base
@@ -14,9 +14,7 @@
 #include <__config>
 #include <chrono>
 #include <system_error>
-#ifndef _LIBCPP_HAS_NO_THREADS
-#include <pthread.h>
-#endif
+#include <__threading_support>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
@@ -26,29 +24,41 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #ifndef _LIBCPP_HAS_NO_THREADS
 
-class _LIBCPP_TYPE_VIS mutex
+#ifndef _LIBCPP_THREAD_SAFETY_ANNOTATION
+#  ifdef _LIBCPP_HAS_THREAD_SAFETY_ANNOTATIONS
+#    define _LIBCPP_THREAD_SAFETY_ANNOTATION(x) __attribute__((x))
+#  else
+#    define _LIBCPP_THREAD_SAFETY_ANNOTATION(x)
+#  endif
+#endif  // _LIBCPP_THREAD_SAFETY_ANNOTATION
+
+class _LIBCPP_TYPE_VIS _LIBCPP_THREAD_SAFETY_ANNOTATION(capability("mutex")) mutex
 {
-    pthread_mutex_t __m_;
+#ifndef _LIBCPP_HAS_NO_CONSTEXPR
+    __libcpp_mutex_t __m_ = _LIBCPP_MUTEX_INITIALIZER;
+#else
+    __libcpp_mutex_t __m_;
+#endif
 
 public:
     _LIBCPP_INLINE_VISIBILITY
 #ifndef _LIBCPP_HAS_NO_CONSTEXPR
-     constexpr mutex() _NOEXCEPT : __m_(PTHREAD_MUTEX_INITIALIZER) {}
+    constexpr mutex() _NOEXCEPT _LIBCPP_DEFAULT
 #else
-     mutex() _NOEXCEPT {__m_ = (pthread_mutex_t)PTHREAD_MUTEX_INITIALIZER;}
+    mutex() _NOEXCEPT {__m_ = (__libcpp_mutex_t)_LIBCPP_MUTEX_INITIALIZER;}
 #endif
-     ~mutex();
+    ~mutex();
 
 private:
     mutex(const mutex&);// = delete;
     mutex& operator=(const mutex&);// = delete;
 
 public:
-    void lock();
-    bool try_lock() _NOEXCEPT;
-    void unlock() _NOEXCEPT;
+    void lock() _LIBCPP_THREAD_SAFETY_ANNOTATION(acquire_capability());
+    bool try_lock() _NOEXCEPT _LIBCPP_THREAD_SAFETY_ANNOTATION(try_acquire_capability(true));
+    void unlock() _NOEXCEPT _LIBCPP_THREAD_SAFETY_ANNOTATION(release_capability());
 
-    typedef pthread_mutex_t* native_handle_type;
+    typedef __libcpp_mutex_t* native_handle_type;
     _LIBCPP_INLINE_VISIBILITY native_handle_type native_handle() {return &__m_;}
 };
 
@@ -70,8 +80,21 @@ constexpr adopt_lock_t  adopt_lock  = adopt_lock_t();
 
 #endif
 
+
+// Forward declare lock_guard as a variadic template even in C++03 to keep
+// the mangling consistent between dialects.
+#if defined(_LIBCPP_ABI_VARIADIC_LOCK_GUARD)
+template <class ..._Mutexes>
+class _LIBCPP_TYPE_VIS_ONLY lock_guard;
+#endif
+
 template <class _Mutex>
-class _LIBCPP_TYPE_VIS_ONLY lock_guard
+class _LIBCPP_TYPE_VIS_ONLY _LIBCPP_THREAD_SAFETY_ANNOTATION(scoped_lockable)
+#if !defined(_LIBCPP_ABI_VARIADIC_LOCK_GUARD)
+lock_guard
+#else
+lock_guard<_Mutex>
+#endif
 {
 public:
     typedef _Mutex mutex_type;
@@ -81,17 +104,17 @@ private:
 public:
 
     _LIBCPP_INLINE_VISIBILITY
-    explicit lock_guard(mutex_type& __m)
+    explicit lock_guard(mutex_type& __m) _LIBCPP_THREAD_SAFETY_ANNOTATION(acquire_capability(__m))
         : __m_(__m) {__m_.lock();}
     _LIBCPP_INLINE_VISIBILITY
-    lock_guard(mutex_type& __m, adopt_lock_t)
+    lock_guard(mutex_type& __m, adopt_lock_t) _LIBCPP_THREAD_SAFETY_ANNOTATION(requires_capability(__m))
         : __m_(__m) {}
     _LIBCPP_INLINE_VISIBILITY
-    ~lock_guard() {__m_.unlock();}
+    ~lock_guard() _LIBCPP_THREAD_SAFETY_ANNOTATION(release_capability()) {__m_.unlock();}
 
 private:
-    lock_guard(lock_guard const&);// = delete;
-    lock_guard& operator=(lock_guard const&);// = delete;
+    lock_guard(lock_guard const&) _LIBCPP_EQUAL_DELETE;
+    lock_guard& operator=(lock_guard const&) _LIBCPP_EQUAL_DELETE;
 };
 
 template <class _Mutex>
@@ -109,24 +132,24 @@ public:
     unique_lock() _NOEXCEPT : __m_(nullptr), __owns_(false) {}
     _LIBCPP_INLINE_VISIBILITY
     explicit unique_lock(mutex_type& __m)
-        : __m_(&__m), __owns_(true) {__m_->lock();}
+        : __m_(_VSTD::addressof(__m)), __owns_(true) {__m_->lock();}
     _LIBCPP_INLINE_VISIBILITY
     unique_lock(mutex_type& __m, defer_lock_t) _NOEXCEPT
-        : __m_(&__m), __owns_(false) {}
+        : __m_(_VSTD::addressof(__m)), __owns_(false) {}
     _LIBCPP_INLINE_VISIBILITY
     unique_lock(mutex_type& __m, try_to_lock_t)
-        : __m_(&__m), __owns_(__m.try_lock()) {}
+        : __m_(_VSTD::addressof(__m)), __owns_(__m.try_lock()) {}
     _LIBCPP_INLINE_VISIBILITY
     unique_lock(mutex_type& __m, adopt_lock_t)
-        : __m_(&__m), __owns_(true) {}
+        : __m_(_VSTD::addressof(__m)), __owns_(true) {}
     template <class _Clock, class _Duration>
     _LIBCPP_INLINE_VISIBILITY
         unique_lock(mutex_type& __m, const chrono::time_point<_Clock, _Duration>& __t)
-            : __m_(&__m), __owns_(__m.try_lock_until(__t)) {}
+            : __m_(_VSTD::addressof(__m)), __owns_(__m.try_lock_until(__t)) {}
     template <class _Rep, class _Period>
     _LIBCPP_INLINE_VISIBILITY
         unique_lock(mutex_type& __m, const chrono::duration<_Rep, _Period>& __d)
-            : __m_(&__m), __owns_(__m.try_lock_for(__d)) {}
+            : __m_(_VSTD::addressof(__m)), __owns_(__m.try_lock_for(__d)) {}
     _LIBCPP_INLINE_VISIBILITY
     ~unique_lock()
     {
@@ -268,13 +291,18 @@ _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(cv_status)
 
 class _LIBCPP_TYPE_VIS condition_variable
 {
-    pthread_cond_t __cv_;
+#ifndef _LIBCPP_HAS_NO_CONSTEXPR
+    __libcpp_condvar_t __cv_ = _LIBCPP_CONDVAR_INITIALIZER;
+#else
+    __libcpp_condvar_t __cv_;
+#endif
+
 public:
     _LIBCPP_INLINE_VISIBILITY
 #ifndef _LIBCPP_HAS_NO_CONSTEXPR
-    constexpr condition_variable() : __cv_(PTHREAD_COND_INITIALIZER) {}
+    constexpr condition_variable() _NOEXCEPT _LIBCPP_DEFAULT
 #else
-    condition_variable() {__cv_ = (pthread_cond_t)PTHREAD_COND_INITIALIZER;}
+    condition_variable() _NOEXCEPT {__cv_ = (__libcpp_condvar_t)_LIBCPP_CONDVAR_INITIALIZER;}
 #endif
     ~condition_variable();
 
@@ -313,7 +341,7 @@ public:
                  const chrono::duration<_Rep, _Period>& __d,
                  _Predicate __pred);
 
-    typedef pthread_cond_t* native_handle_type;
+    typedef __libcpp_condvar_t* native_handle_type;
     _LIBCPP_INLINE_VISIBILITY native_handle_type native_handle() {return &__cv_;}
 
 private:
diff --git a/include/__threading_support b/include/__threading_support
new file mode 100644
index 000000000000..c9a4ea9d0947
--- /dev/null
+++ b/include/__threading_support
@@ -0,0 +1,205 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_THREADING_SUPPORT
+#define _LIBCPP_THREADING_SUPPORT
+
+#include <__config>
+
+#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
+#pragma GCC system_header
+#endif
+
+#ifndef _LIBCPP_HAS_NO_THREADS
+
+#if defined(_LIBCPP_HAS_THREAD_API_PTHREAD)
+#include <pthread.h>
+#include <sched.h>
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if defined(_LIBCPP_HAS_THREAD_API_PTHREAD)
+
+// Mutex
+#define _LIBCPP_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
+typedef pthread_mutex_t __libcpp_mutex_t;
+
+inline _LIBCPP_ALWAYS_INLINE
+int __libcpp_recursive_mutex_init(__libcpp_mutex_t* __m)
+{
+    pthread_mutexattr_t attr;
+    int __ec = pthread_mutexattr_init(&attr);
+    if (__ec) return __ec;
+    __ec = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+    if (__ec)
+    {
+        pthread_mutexattr_destroy(&attr);
+        return __ec;
+    }
+    __ec = pthread_mutex_init(__m, &attr);
+    if (__ec)
+    {
+        pthread_mutexattr_destroy(&attr);
+        return __ec;
+    }
+    __ec = pthread_mutexattr_destroy(&attr);
+    if (__ec)
+    {
+        pthread_mutex_destroy(__m);
+        return __ec;
+    }
+    return 0;
+}
+
+inline _LIBCPP_ALWAYS_INLINE
+int __libcpp_mutex_lock(__libcpp_mutex_t* __m)
+{
+    return pthread_mutex_lock(__m);
+}
+
+inline _LIBCPP_ALWAYS_INLINE
+int __libcpp_mutex_trylock(__libcpp_mutex_t* __m)
+{
+    return pthread_mutex_trylock(__m);
+}
+
+inline _LIBCPP_ALWAYS_INLINE
+int __libcpp_mutex_unlock(__libcpp_mutex_t* __m)
+{
+    return pthread_mutex_unlock(__m);
+}
+
+inline _LIBCPP_ALWAYS_INLINE
+int __libcpp_mutex_destroy(__libcpp_mutex_t* __m)
+{
+    return pthread_mutex_destroy(__m);
+}
+
+// Condition variable
+#define _LIBCPP_CONDVAR_INITIALIZER PTHREAD_COND_INITIALIZER
+typedef pthread_cond_t __libcpp_condvar_t;
+
+inline _LIBCPP_ALWAYS_INLINE
+int __libcpp_condvar_signal(__libcpp_condvar_t* __cv)
+{
+    return pthread_cond_signal(__cv);
+}
+
+inline _LIBCPP_ALWAYS_INLINE
+int __libcpp_condvar_broadcast(__libcpp_condvar_t* __cv)
+{
+    return pthread_cond_broadcast(__cv);
+}
+
+inline _LIBCPP_ALWAYS_INLINE
+int __libcpp_condvar_wait(__libcpp_condvar_t* __cv, __libcpp_mutex_t* __m)
+{
+    return pthread_cond_wait(__cv, __m);
+}
+
+inline _LIBCPP_ALWAYS_INLINE
+int __libcpp_condvar_timedwait(__libcpp_condvar_t* __cv, __libcpp_mutex_t* __m, timespec* __ts)
+{
+    return pthread_cond_timedwait(__cv, __m, __ts);
+}
+
+inline _LIBCPP_ALWAYS_INLINE
+int __libcpp_condvar_destroy(__libcpp_condvar_t* __cv)
+{
+    return pthread_cond_destroy(__cv);
+}
+
+// Thread id
+typedef pthread_t __libcpp_thread_id;
+
+// Returns non-zero if the thread ids are equal, otherwise 0
+inline _LIBCPP_ALWAYS_INLINE
+bool __libcpp_thread_id_equal(__libcpp_thread_id t1, __libcpp_thread_id t2)
+{
+    return pthread_equal(t1, t2) != 0;
+}
+
+// Returns non-zero if t1 < t2, otherwise 0
+inline _LIBCPP_ALWAYS_INLINE
+bool __libcpp_thread_id_less(__libcpp_thread_id t1, __libcpp_thread_id t2)
+{
+    return t1 < t2;
+}
+
+// Thread
+typedef pthread_t __libcpp_thread_t;
+
+inline _LIBCPP_ALWAYS_INLINE
+int __libcpp_thread_create(__libcpp_thread_t* __t, void* (*__func)(void*), void* __arg)
+{
+    return pthread_create(__t, 0, __func, __arg);
+}
+
+inline _LIBCPP_ALWAYS_INLINE
+__libcpp_thread_id __libcpp_thread_get_current_id()
+{
+    return pthread_self();
+}
+
+inline _LIBCPP_ALWAYS_INLINE
+__libcpp_thread_id __libcpp_thread_get_id(const __libcpp_thread_t* __t)
+{
+    return *__t;
+}
+
+inline _LIBCPP_ALWAYS_INLINE
+int __libcpp_thread_join(__libcpp_thread_t* __t)
+{
+    return pthread_join(*__t, 0);
+}
+
+inline _LIBCPP_ALWAYS_INLINE
+int __libcpp_thread_detach(__libcpp_thread_t* __t)
+{
+    return pthread_detach(*__t);
+}
+
+inline _LIBCPP_ALWAYS_INLINE
+void __libcpp_thread_yield()
+{
+    sched_yield();
+}
+
+// Thread local storage
+typedef pthread_key_t __libcpp_tl_key;
+
+inline _LIBCPP_ALWAYS_INLINE
+int __libcpp_tl_create(__libcpp_tl_key* __key, void (*__at_exit)(void*))
+{
+    return pthread_key_create(__key, __at_exit);
+}
+
+inline _LIBCPP_ALWAYS_INLINE
+void* __libcpp_tl_get(__libcpp_tl_key __key)
+{
+    return pthread_getspecific(__key);
+}
+
+inline _LIBCPP_ALWAYS_INLINE
+void __libcpp_tl_set(__libcpp_tl_key __key, void* __p)
+{
+    pthread_setspecific(__key, __p);
+}
+
+#else // !_LIBCPP_HAS_THREAD_API_PTHREAD
+  #error "No thread API selected."
+#endif
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_HAS_NO_THREADS
+
+#endif // _LIBCPP_THREADING_SUPPORT
diff --git a/include/__tree b/include/__tree
index 94565bc3f74c..bfcec78d4c9b 100644
--- a/include/__tree
+++ b/include/__tree
@@ -29,6 +29,22 @@ template <class _Tp, class _NodePtr, class _DiffType>
 template <class _Tp, class _ConstNodePtr, class _DiffType>
     class _LIBCPP_TYPE_VIS_ONLY __tree_const_iterator;
 
+template <class _Pointer> class __tree_end_node;
+template <class _VoidPtr> class __tree_node_base;
+template <class _Tp, class _VoidPtr> class __tree_node;
+
+#ifndef _LIBCPP_CXX03_LANG
+template <class _Key, class _Value>
+union __value_type;
+#else
+template <class _Key, class _Value>
+struct __value_type;
+#endif
+
+template <class _Allocator> class __map_node_destructor;
+template <class _TreeIterator> class _LIBCPP_TYPE_VIS_ONLY __map_iterator;
+template <class _TreeIterator> class _LIBCPP_TYPE_VIS_ONLY __map_const_iterator;
+
 /*
 
 _NodePtr algorithms
@@ -149,21 +165,36 @@ __tree_next(_NodePtr __x) _NOEXCEPT
     if (__x->__right_ != nullptr)
         return __tree_min(__x->__right_);
     while (!__tree_is_left_child(__x))
-        __x = __x->__parent_;
-    return __x->__parent_;
+        __x = __x->__parent_unsafe();
+    return __x->__parent_unsafe();
+}
+
+template <class _EndNodePtr, class _NodePtr>
+inline _LIBCPP_INLINE_VISIBILITY
+_EndNodePtr
+__tree_next_iter(_NodePtr __x) _NOEXCEPT
+{
+    if (__x->__right_ != nullptr)
+        return static_cast<_EndNodePtr>(__tree_min(__x->__right_));
+    while (!__tree_is_left_child(__x))
+        __x = __x->__parent_unsafe();
+    return static_cast<_EndNodePtr>(__x->__parent_);
 }
 
 // Returns:  pointer to the previous in-order node before __x.
 // Precondition:  __x != nullptr.
-template <class _NodePtr>
+// Note: __x may be the end node.
+template <class _NodePtr, class _EndNodePtr>
+inline _LIBCPP_INLINE_VISIBILITY
 _NodePtr
-__tree_prev(_NodePtr __x) _NOEXCEPT
+__tree_prev_iter(_EndNodePtr __x) _NOEXCEPT
 {
     if (__x->__left_ != nullptr)
         return __tree_max(__x->__left_);
-    while (__tree_is_left_child(__x))
-        __x = __x->__parent_;
-    return __x->__parent_;
+    _NodePtr __xx = static_cast<_NodePtr>(__x);
+    while (__tree_is_left_child(__xx))
+        __xx = __xx->__parent_unsafe();
+    return __xx->__parent_unsafe();
 }
 
 // Returns:  pointer to a node which has no children
@@ -199,14 +230,14 @@ __tree_left_rotate(_NodePtr __x) _NOEXCEPT
     _NodePtr __y = __x->__right_;
     __x->__right_ = __y->__left_;
     if (__x->__right_ != nullptr)
-        __x->__right_->__parent_ = __x;
+        __x->__right_->__set_parent(__x);
     __y->__parent_ = __x->__parent_;
     if (__tree_is_left_child(__x))
         __x->__parent_->__left_ = __y;
     else
-        __x->__parent_->__right_ = __y;
+        __x->__parent_unsafe()->__right_ = __y;
     __y->__left_ = __x;
-    __x->__parent_ = __y;
+    __x->__set_parent(__y);
 }
 
 // Effects:  Makes __x->__left_ the subtree root with __x as its right child
@@ -219,14 +250,14 @@ __tree_right_rotate(_NodePtr __x) _NOEXCEPT
     _NodePtr __y = __x->__left_;
     __x->__left_ = __y->__right_;
     if (__x->__left_ != nullptr)
-        __x->__left_->__parent_ = __x;
+        __x->__left_->__set_parent(__x);
     __y->__parent_ = __x->__parent_;
     if (__tree_is_left_child(__x))
         __x->__parent_->__left_ = __y;
     else
-        __x->__parent_->__right_ = __y;
+        __x->__parent_unsafe()->__right_ = __y;
     __y->__right_ = __x;
-    __x->__parent_ = __y;
+    __x->__set_parent(__y);
 }
 
 // Effects:  Rebalances __root after attaching __x to a leaf.
@@ -242,17 +273,17 @@ void
 __tree_balance_after_insert(_NodePtr __root, _NodePtr __x) _NOEXCEPT
 {
     __x->__is_black_ = __x == __root;
-    while (__x != __root && !__x->__parent_->__is_black_)
+    while (__x != __root && !__x->__parent_unsafe()->__is_black_)
     {
         // __x->__parent_ != __root because __x->__parent_->__is_black == false
-        if (__tree_is_left_child(__x->__parent_))
+        if (__tree_is_left_child(__x->__parent_unsafe()))
         {
-            _NodePtr __y = __x->__parent_->__parent_->__right_;
+            _NodePtr __y = __x->__parent_unsafe()->__parent_unsafe()->__right_;
             if (__y != nullptr && !__y->__is_black_)
             {
-                __x = __x->__parent_;
+                __x = __x->__parent_unsafe();
                 __x->__is_black_ = true;
-                __x = __x->__parent_;
+                __x = __x->__parent_unsafe();
                 __x->__is_black_ = __x == __root;
                 __y->__is_black_ = true;
             }
@@ -260,12 +291,12 @@ __tree_balance_after_insert(_NodePtr __root, _NodePtr __x) _NOEXCEPT
             {
                 if (!__tree_is_left_child(__x))
                 {
-                    __x = __x->__parent_;
+                    __x = __x->__parent_unsafe();
                     __tree_left_rotate(__x);
                 }
-                __x = __x->__parent_;
+                __x = __x->__parent_unsafe();
                 __x->__is_black_ = true;
-                __x = __x->__parent_;
+                __x = __x->__parent_unsafe();
                 __x->__is_black_ = false;
                 __tree_right_rotate(__x);
                 break;
@@ -273,12 +304,12 @@ __tree_balance_after_insert(_NodePtr __root, _NodePtr __x) _NOEXCEPT
         }
         else
         {
-            _NodePtr __y = __x->__parent_->__parent_->__left_;
+            _NodePtr __y = __x->__parent_unsafe()->__parent_->__left_;
             if (__y != nullptr && !__y->__is_black_)
             {
-                __x = __x->__parent_;
+                __x = __x->__parent_unsafe();
                 __x->__is_black_ = true;
-                __x = __x->__parent_;
+                __x = __x->__parent_unsafe();
                 __x->__is_black_ = __x == __root;
                 __y->__is_black_ = true;
             }
@@ -286,12 +317,12 @@ __tree_balance_after_insert(_NodePtr __root, _NodePtr __x) _NOEXCEPT
             {
                 if (__tree_is_left_child(__x))
                 {
-                    __x = __x->__parent_;
+                    __x = __x->__parent_unsafe();
                     __tree_right_rotate(__x);
                 }
-                __x = __x->__parent_;
+                __x = __x->__parent_unsafe();
                 __x->__is_black_ = true;
-                __x = __x->__parent_;
+                __x = __x->__parent_unsafe();
                 __x->__is_black_ = false;
                 __tree_left_rotate(__x);
                 break;
@@ -328,13 +359,13 @@ __tree_remove(_NodePtr __root, _NodePtr __z) _NOEXCEPT
     {
         __y->__parent_->__left_ = __x;
         if (__y != __root)
-            __w = __y->__parent_->__right_;
+            __w = __y->__parent_unsafe()->__right_;
         else
             __root = __x;  // __w == nullptr
     }
     else
     {
-        __y->__parent_->__right_ = __x;
+        __y->__parent_unsafe()->__right_ = __x;
         // __y can't be root if it is a right child
         __w = __y->__parent_->__left_;
     }
@@ -348,12 +379,12 @@ __tree_remove(_NodePtr __root, _NodePtr __z) _NOEXCEPT
         if (__tree_is_left_child(__z))
             __y->__parent_->__left_ = __y;
         else
-            __y->__parent_->__right_ = __y;
+            __y->__parent_unsafe()->__right_ = __y;
         __y->__left_ = __z->__left_;
-        __y->__left_->__parent_ = __y;
+        __y->__left_->__set_parent(__y);
         __y->__right_ = __z->__right_;
         if (__y->__right_ != nullptr)
-            __y->__right_->__parent_ = __y;
+            __y->__right_->__set_parent(__y);
         __y->__is_black_ = __z->__is_black_;
         if (__root == __z)
             __root = __y;
@@ -390,8 +421,8 @@ __tree_remove(_NodePtr __root, _NodePtr __z) _NOEXCEPT
                     if (!__w->__is_black_)
                     {
                         __w->__is_black_ = true;
-                        __w->__parent_->__is_black_ = false;
-                        __tree_left_rotate(__w->__parent_);
+                        __w->__parent_unsafe()->__is_black_ = false;
+                        __tree_left_rotate(__w->__parent_unsafe());
                         // __x is still valid
                         // reset __root only if necessary
                         if (__root == __w->__left_)
@@ -404,7 +435,7 @@ __tree_remove(_NodePtr __root, _NodePtr __z) _NOEXCEPT
                         (__w->__right_ == nullptr || __w->__right_->__is_black_))
                     {
                         __w->__is_black_ = false;
-                        __x = __w->__parent_;
+                        __x = __w->__parent_unsafe();
                         // __x can no longer be null
                         if (__x == __root || !__x->__is_black_)
                         {
@@ -413,7 +444,7 @@ __tree_remove(_NodePtr __root, _NodePtr __z) _NOEXCEPT
                         }
                         // reset sibling, and it still can't be null
                         __w = __tree_is_left_child(__x) ?
-                                    __x->__parent_->__right_ :
+                                    __x->__parent_unsafe()->__right_ :
                                     __x->__parent_->__left_;
                         // continue;
                     }
@@ -427,13 +458,13 @@ __tree_remove(_NodePtr __root, _NodePtr __z) _NOEXCEPT
                             __tree_right_rotate(__w);
                             // __w is known not to be root, so root hasn't changed
                             // reset sibling, and it still can't be null
-                            __w = __w->__parent_;
+                            __w = __w->__parent_unsafe();
                         }
                         // __w has a right red child, left child may be null
-                        __w->__is_black_ = __w->__parent_->__is_black_;
-                        __w->__parent_->__is_black_ = true;
+                        __w->__is_black_ = __w->__parent_unsafe()->__is_black_;
+                        __w->__parent_unsafe()->__is_black_ = true;
                         __w->__right_->__is_black_ = true;
-                        __tree_left_rotate(__w->__parent_);
+                        __tree_left_rotate(__w->__parent_unsafe());
                         break;
                     }
                 }
@@ -442,8 +473,8 @@ __tree_remove(_NodePtr __root, _NodePtr __z) _NOEXCEPT
                     if (!__w->__is_black_)
                     {
                         __w->__is_black_ = true;
-                        __w->__parent_->__is_black_ = false;
-                        __tree_right_rotate(__w->__parent_);
+                        __w->__parent_unsafe()->__is_black_ = false;
+                        __tree_right_rotate(__w->__parent_unsafe());
                         // __x is still valid
                         // reset __root only if necessary
                         if (__root == __w->__right_)
@@ -456,7 +487,7 @@ __tree_remove(_NodePtr __root, _NodePtr __z) _NOEXCEPT
                         (__w->__right_ == nullptr || __w->__right_->__is_black_))
                     {
                         __w->__is_black_ = false;
-                        __x = __w->__parent_;
+                        __x = __w->__parent_unsafe();
                         // __x can no longer be null
                         if (!__x->__is_black_ || __x == __root)
                         {
@@ -465,7 +496,7 @@ __tree_remove(_NodePtr __root, _NodePtr __z) _NOEXCEPT
                         }
                         // reset sibling, and it still can't be null
                         __w = __tree_is_left_child(__x) ?
-                                    __x->__parent_->__right_ :
+                                    __x->__parent_unsafe()->__right_ :
                                     __x->__parent_->__left_;
                         // continue;
                     }
@@ -479,13 +510,13 @@ __tree_remove(_NodePtr __root, _NodePtr __z) _NOEXCEPT
                             __tree_left_rotate(__w);
                             // __w is known not to be root, so root hasn't changed
                             // reset sibling, and it still can't be null
-                            __w = __w->__parent_;
+                            __w = __w->__parent_unsafe();
                         }
                         // __w has a left red child, right child may be null
-                        __w->__is_black_ = __w->__parent_->__is_black_;
-                        __w->__parent_->__is_black_ = true;
+                        __w->__is_black_ = __w->__parent_unsafe()->__is_black_;
+                        __w->__parent_unsafe()->__is_black_ = true;
                         __w->__left_->__is_black_ = true;
-                        __tree_right_rotate(__w->__parent_);
+                        __tree_right_rotate(__w->__parent_unsafe());
                         break;
                     }
                 }
@@ -494,41 +525,182 @@ __tree_remove(_NodePtr __root, _NodePtr __z) _NOEXCEPT
     }
 }
 
-template <class _Allocator> class __map_node_destructor;
+// node traits
+
+
+#ifndef _LIBCPP_CXX03_LANG
+template <class _Tp>
+struct __is_tree_value_type_imp : false_type {};
+
+template <class _Key, class _Value>
+struct __is_tree_value_type_imp<__value_type<_Key, _Value>> : true_type {};
+
+template <class ..._Args>
+struct __is_tree_value_type : false_type {};
+
+template <class _One>
+struct __is_tree_value_type<_One> : __is_tree_value_type_imp<typename __uncvref<_One>::type> {};
+#endif
+
+template <class _Tp>
+struct __tree_key_value_types {
+  typedef _Tp key_type;
+  typedef _Tp __node_value_type;
+  typedef _Tp __container_value_type;
+  static const bool __is_map = false;
+
+  _LIBCPP_INLINE_VISIBILITY
+  static key_type const& __get_key(_Tp const& __v) {
+    return __v;
+  }
+  _LIBCPP_INLINE_VISIBILITY
+  static __container_value_type const& __get_value(__node_value_type const& __v) {
+    return __v;
+  }
+  _LIBCPP_INLINE_VISIBILITY
+  static __container_value_type* __get_ptr(__node_value_type& __n) {
+    return _VSTD::addressof(__n);
+  }
+
+#ifndef _LIBCPP_CXX03_LANG
+  _LIBCPP_INLINE_VISIBILITY
+  static  __container_value_type&& __move(__node_value_type& __v) {
+    return _VSTD::move(__v);
+  }
+#endif
+};
+
+template <class _Key, class _Tp>
+struct __tree_key_value_types<__value_type<_Key, _Tp> > {
+  typedef _Key                                         key_type;
+  typedef _Tp                                          mapped_type;
+  typedef __value_type<_Key, _Tp>                      __node_value_type;
+  typedef pair<const _Key, _Tp>                        __container_value_type;
+  typedef pair<_Key, _Tp>                              __nc_value_type;
+  typedef __container_value_type                       __map_value_type;
+  static const bool __is_map = true;
+
+  _LIBCPP_INLINE_VISIBILITY
+  static key_type const&
+  __get_key(__node_value_type const& __t) {
+    return __t.__cc.first;
+  }
+
+  template <class _Up>
+  _LIBCPP_INLINE_VISIBILITY
+  static typename enable_if<__is_same_uncvref<_Up, __container_value_type>::value,
+      key_type const&>::type
+  __get_key(_Up& __t) {
+    return __t.first;
+  }
+
+  _LIBCPP_INLINE_VISIBILITY
+  static __container_value_type const&
+  __get_value(__node_value_type const& __t) {
+    return __t.__cc;
+  }
+
+  template <class _Up>
+  _LIBCPP_INLINE_VISIBILITY
+  static typename enable_if<__is_same_uncvref<_Up, __container_value_type>::value,
+      __container_value_type const&>::type
+  __get_value(_Up& __t) {
+    return __t;
+  }
+
+  _LIBCPP_INLINE_VISIBILITY
+  static __container_value_type* __get_ptr(__node_value_type& __n) {
+    return _VSTD::addressof(__n.__cc);
+  }
+
+#ifndef _LIBCPP_CXX03_LANG
+  _LIBCPP_INLINE_VISIBILITY
+  static  __nc_value_type&& __move(__node_value_type& __v) {
+    return _VSTD::move(__v.__nc);
+  }
+#endif
+};
+
+template <class _VoidPtr>
+struct __tree_node_base_types {
+  typedef _VoidPtr                                               __void_pointer;
+
+  typedef __tree_node_base<__void_pointer>                      __node_base_type;
+  typedef typename __rebind_pointer<_VoidPtr, __node_base_type>::type
+                                                             __node_base_pointer;
+
+  typedef __tree_end_node<__node_base_pointer>                  __end_node_type;
+  typedef typename __rebind_pointer<_VoidPtr, __end_node_type>::type
+                                                             __end_node_pointer;
+#if defined(_LIBCPP_ABI_TREE_REMOVE_NODE_POINTER_UB)
+  typedef __end_node_pointer __parent_pointer;
+#else
+  typedef typename conditional<
+      is_pointer<__end_node_pointer>::value,
+        __end_node_pointer,
+        __node_base_pointer>::type __parent_pointer;
+#endif
 
-template <class _Allocator>
-class __tree_node_destructor
-{
-    typedef _Allocator                                      allocator_type;
-    typedef allocator_traits<allocator_type>                __alloc_traits;
-    typedef typename __alloc_traits::value_type::value_type value_type;
-public:
-    typedef typename __alloc_traits::pointer                pointer;
 private:
+  static_assert((is_same<typename pointer_traits<_VoidPtr>::element_type, void>::value),
+                  "_VoidPtr does not point to unqualified void type");
+};
 
-    allocator_type& __na_;
+template <class _Tp, class _AllocPtr, class _KVTypes = __tree_key_value_types<_Tp>,
+         bool = _KVTypes::__is_map>
+struct __tree_map_pointer_types {};
+
+template <class _Tp, class _AllocPtr, class _KVTypes>
+struct __tree_map_pointer_types<_Tp, _AllocPtr, _KVTypes, true> {
+  typedef typename _KVTypes::__map_value_type   _Mv;
+  typedef typename __rebind_pointer<_AllocPtr, _Mv>::type
+                                                       __map_value_type_pointer;
+  typedef typename __rebind_pointer<_AllocPtr, const _Mv>::type
+                                                 __const_map_value_type_pointer;
+};
 
-    __tree_node_destructor& operator=(const __tree_node_destructor&);
+template <class _NodePtr, class _NodeT = typename pointer_traits<_NodePtr>::element_type>
+struct __tree_node_types;
 
+template <class _NodePtr, class _Tp, class _VoidPtr>
+struct __tree_node_types<_NodePtr, __tree_node<_Tp, _VoidPtr> >
+    : public __tree_node_base_types<_VoidPtr>,
+             __tree_key_value_types<_Tp>,
+             __tree_map_pointer_types<_Tp, _VoidPtr>
+{
+  typedef __tree_node_base_types<_VoidPtr> __base;
+  typedef __tree_key_value_types<_Tp>      __key_base;
+  typedef __tree_map_pointer_types<_Tp, _VoidPtr> __map_pointer_base;
 public:
-    bool __value_constructed;
-
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __tree_node_destructor(allocator_type& __na, bool __val = false) _NOEXCEPT
-        : __na_(__na),
-          __value_constructed(__val)
-        {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    void operator()(pointer __p) _NOEXCEPT
-    {
-        if (__value_constructed)
-            __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_));
-        if (__p)
-            __alloc_traits::deallocate(__na_, __p, 1);
-    }
+  typedef typename pointer_traits<_NodePtr>::element_type       __node_type;
+  typedef _NodePtr                                              __node_pointer;
+
+  typedef _Tp                                                 __node_value_type;
+  typedef typename __rebind_pointer<_VoidPtr, __node_value_type>::type
+                                                      __node_value_type_pointer;
+  typedef typename __rebind_pointer<_VoidPtr, const __node_value_type>::type
+                                                __const_node_value_type_pointer;
+#if defined(_LIBCPP_ABI_TREE_REMOVE_NODE_POINTER_UB)
+  typedef typename __base::__end_node_pointer __iter_pointer;
+#else
+  typedef typename conditional<
+      is_pointer<__node_pointer>::value,
+        typename __base::__end_node_pointer,
+        __node_pointer>::type __iter_pointer;
+#endif
+private:
+    static_assert(!is_const<__node_type>::value,
+                "_NodePtr should never be a pointer to const");
+    static_assert((is_same<typename __rebind_pointer<_VoidPtr, __node_type>::type,
+                          _NodePtr>::value), "_VoidPtr does not rebind to _NodePtr.");
+};
 
-    template <class> friend class __map_node_destructor;
+template <class _ValueTp, class _VoidPtr>
+struct __make_tree_node_types {
+  typedef typename __rebind_pointer<_VoidPtr, __tree_node<_ValueTp, _VoidPtr> >::type
+                                                                        _NodePtr;
+  typedef __tree_node_types<_NodePtr> type;
 };
 
 // node
@@ -546,26 +718,30 @@ public:
 
 template <class _VoidPtr>
 class __tree_node_base
-    : public __tree_end_node
-             <
-                typename __rebind_pointer<_VoidPtr, __tree_node_base<_VoidPtr> >::type
-             >
+    : public __tree_node_base_types<_VoidPtr>::__end_node_type
 {
-    __tree_node_base(const __tree_node_base&);
-    __tree_node_base& operator=(const __tree_node_base&);
-public:
-    typedef typename __rebind_pointer<_VoidPtr, __tree_node_base>::type pointer;
-    typedef typename __rebind_pointer<_VoidPtr, const __tree_node_base>::type const_pointer;
+    typedef __tree_node_base_types<_VoidPtr> _NodeBaseTypes;
 
-    typedef __tree_end_node<pointer> base;
+public:
+    typedef typename _NodeBaseTypes::__node_base_pointer pointer;
+    typedef typename _NodeBaseTypes::__parent_pointer __parent_pointer;
 
-    pointer __right_;
-    pointer __parent_;
+    pointer          __right_;
+    __parent_pointer __parent_;
     bool __is_black_;
 
     _LIBCPP_INLINE_VISIBILITY
-    __tree_node_base() _NOEXCEPT
-        : __right_(), __parent_(), __is_black_(false) {}
+    pointer __parent_unsafe() const { return static_cast<pointer>(__parent_);}
+
+    _LIBCPP_INLINE_VISIBILITY
+    void __set_parent(pointer __p) {
+        __parent_ = static_cast<__parent_pointer>(__p);
+    }
+
+private:
+  ~__tree_node_base() _LIBCPP_EQUAL_DELETE;
+  __tree_node_base(__tree_node_base const&) _LIBCPP_EQUAL_DELETE;
+  __tree_node_base& operator=(__tree_node_base const&) _LIBCPP_EQUAL_DELETE;
 };
 
 template <class _Tp, class _VoidPtr>
@@ -573,41 +749,71 @@ class __tree_node
     : public __tree_node_base<_VoidPtr>
 {
 public:
-    typedef __tree_node_base<_VoidPtr> base;
-    typedef _Tp value_type;
+    typedef _Tp __node_value_type;
 
-    value_type __value_;
+    __node_value_type __value_;
+
+private:
+  ~__tree_node() _LIBCPP_EQUAL_DELETE;
+  __tree_node(__tree_node const&) _LIBCPP_EQUAL_DELETE;
+  __tree_node& operator=(__tree_node const&) _LIBCPP_EQUAL_DELETE;
+};
+
+
+template <class _Allocator>
+class __tree_node_destructor
+{
+    typedef _Allocator                                      allocator_type;
+    typedef allocator_traits<allocator_type>                __alloc_traits;
+
+public:
+    typedef typename __alloc_traits::pointer                pointer;
+private:
+    typedef __tree_node_types<pointer> _NodeTypes;
+    allocator_type& __na_;
+
+    __tree_node_destructor& operator=(const __tree_node_destructor&);
+
+public:
+    bool __value_constructed;
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit __tree_node_destructor(allocator_type& __na, bool __val = false) _NOEXCEPT
+        : __na_(__na),
+          __value_constructed(__val)
+        {}
 
-#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
-    template <class ..._Args>
-        _LIBCPP_INLINE_VISIBILITY
-        explicit __tree_node(_Args&& ...__args)
-            : __value_(_VSTD::forward<_Args>(__args)...) {}
-#else  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
     _LIBCPP_INLINE_VISIBILITY
-    explicit __tree_node(const value_type& __v)
-            : __value_(__v) {}
-#endif  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
+    void operator()(pointer __p) _NOEXCEPT
+    {
+        if (__value_constructed)
+            __alloc_traits::destroy(__na_, _NodeTypes::__get_ptr(__p->__value_));
+        if (__p)
+            __alloc_traits::deallocate(__na_, __p, 1);
+    }
+
+    template <class> friend class __map_node_destructor;
 };
 
-template <class _TreeIterator> class _LIBCPP_TYPE_VIS_ONLY __map_iterator;
-template <class _TreeIterator> class _LIBCPP_TYPE_VIS_ONLY __map_const_iterator;
 
 template <class _Tp, class _NodePtr, class _DiffType>
 class _LIBCPP_TYPE_VIS_ONLY __tree_iterator
 {
-    typedef _NodePtr                                              __node_pointer;
-    typedef typename pointer_traits<__node_pointer>::element_type __node;
+    typedef __tree_node_types<_NodePtr>                     _NodeTypes;
+    typedef _NodePtr                                        __node_pointer;
+    typedef typename _NodeTypes::__node_base_pointer        __node_base_pointer;
+    typedef typename _NodeTypes::__end_node_pointer         __end_node_pointer;
+    typedef typename _NodeTypes::__iter_pointer             __iter_pointer;
+    typedef pointer_traits<__node_pointer> __pointer_traits;
 
-    __node_pointer __ptr_;
+    __iter_pointer __ptr_;
 
-    typedef pointer_traits<__node_pointer> __pointer_traits;
 public:
-    typedef bidirectional_iterator_tag iterator_category;
-    typedef _Tp                        value_type;
-    typedef _DiffType                  difference_type;
-    typedef value_type&                reference;
-    typedef typename __rebind_pointer<__node_pointer, value_type>::type pointer;
+    typedef bidirectional_iterator_tag                     iterator_category;
+    typedef _Tp                                            value_type;
+    typedef _DiffType                                      difference_type;
+    typedef value_type&                                    reference;
+    typedef typename _NodeTypes::__node_value_type_pointer pointer;
 
     _LIBCPP_INLINE_VISIBILITY __tree_iterator() _NOEXCEPT
 #if _LIBCPP_STD_VER > 11
@@ -615,14 +821,15 @@ public:
 #endif
     {}
 
-    _LIBCPP_INLINE_VISIBILITY reference operator*() const {return __ptr_->__value_;}
+    _LIBCPP_INLINE_VISIBILITY reference operator*() const
+        {return __get_np()->__value_;}
     _LIBCPP_INLINE_VISIBILITY pointer operator->() const
-        {return pointer_traits<pointer>::pointer_to(__ptr_->__value_);}
+        {return pointer_traits<pointer>::pointer_to(__get_np()->__value_);}
 
     _LIBCPP_INLINE_VISIBILITY
     __tree_iterator& operator++() {
-      __ptr_ = static_cast<__node_pointer>(
-          __tree_next(static_cast<typename __node::base::pointer>(__ptr_)));
+      __ptr_ = static_cast<__iter_pointer>(
+          __tree_next_iter<__end_node_pointer>(static_cast<__node_base_pointer>(__ptr_)));
       return *this;
     }
     _LIBCPP_INLINE_VISIBILITY
@@ -631,8 +838,8 @@ public:
 
     _LIBCPP_INLINE_VISIBILITY
     __tree_iterator& operator--() {
-      __ptr_ = static_cast<__node_pointer>(
-          __tree_prev(static_cast<typename __node::base::pointer>(__ptr_)));
+      __ptr_ = static_cast<__iter_pointer>(__tree_prev_iter<__node_base_pointer>(
+          static_cast<__end_node_pointer>(__ptr_)));
       return *this;
     }
     _LIBCPP_INLINE_VISIBILITY
@@ -649,6 +856,10 @@ public:
 private:
     _LIBCPP_INLINE_VISIBILITY
     explicit __tree_iterator(__node_pointer __p) _NOEXCEPT : __ptr_(__p) {}
+    _LIBCPP_INLINE_VISIBILITY
+    explicit __tree_iterator(__end_node_pointer __p) _NOEXCEPT : __ptr_(__p) {}
+    _LIBCPP_INLINE_VISIBILITY
+    __node_pointer __get_np() const { return static_cast<__node_pointer>(__ptr_); }
     template <class, class, class> friend class __tree;
     template <class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY __tree_const_iterator;
     template <class> friend class _LIBCPP_TYPE_VIS_ONLY __map_iterator;
@@ -658,21 +869,24 @@ private:
     template <class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY multiset;
 };
 
-template <class _Tp, class _ConstNodePtr, class _DiffType>
+template <class _Tp, class _NodePtr, class _DiffType>
 class _LIBCPP_TYPE_VIS_ONLY __tree_const_iterator
 {
-    typedef _ConstNodePtr                                         __node_pointer;
-    typedef typename pointer_traits<__node_pointer>::element_type __node;
+    typedef __tree_node_types<_NodePtr>                     _NodeTypes;
+    typedef typename _NodeTypes::__node_pointer             __node_pointer;
+    typedef typename _NodeTypes::__node_base_pointer        __node_base_pointer;
+    typedef typename _NodeTypes::__end_node_pointer         __end_node_pointer;
+    typedef typename _NodeTypes::__iter_pointer             __iter_pointer;
+    typedef pointer_traits<__node_pointer> __pointer_traits;
 
-    __node_pointer __ptr_;
+    __iter_pointer __ptr_;
 
-    typedef pointer_traits<__node_pointer> __pointer_traits;
 public:
-    typedef bidirectional_iterator_tag       iterator_category;
-    typedef _Tp                              value_type;
-    typedef _DiffType                        difference_type;
-    typedef const value_type&                reference;
-    typedef typename __rebind_pointer<__node_pointer, const value_type>::type pointer;
+    typedef bidirectional_iterator_tag                           iterator_category;
+    typedef _Tp                                                  value_type;
+    typedef _DiffType                                            difference_type;
+    typedef const value_type&                                    reference;
+    typedef typename _NodeTypes::__const_node_value_type_pointer pointer;
 
     _LIBCPP_INLINE_VISIBILITY __tree_const_iterator() _NOEXCEPT
 #if _LIBCPP_STD_VER > 11
@@ -681,26 +895,22 @@ public:
     {}
 
 private:
-    typedef typename remove_const<__node>::type  __non_const_node;
-    typedef typename __rebind_pointer<__node_pointer, __non_const_node>::type
-        __non_const_node_pointer;
-    typedef __tree_iterator<value_type, __non_const_node_pointer, difference_type>
-                                                 __non_const_iterator;
+    typedef __tree_iterator<value_type, __node_pointer, difference_type>
+                                                           __non_const_iterator;
 public:
     _LIBCPP_INLINE_VISIBILITY
     __tree_const_iterator(__non_const_iterator __p) _NOEXCEPT
         : __ptr_(__p.__ptr_) {}
 
-    _LIBCPP_INLINE_VISIBILITY reference operator*() const {return __ptr_->__value_;}
+    _LIBCPP_INLINE_VISIBILITY reference operator*() const
+        {return __get_np()->__value_;}
     _LIBCPP_INLINE_VISIBILITY pointer operator->() const
-        {return pointer_traits<pointer>::pointer_to(__ptr_->__value_);}
+        {return pointer_traits<pointer>::pointer_to(__get_np()->__value_);}
 
     _LIBCPP_INLINE_VISIBILITY
     __tree_const_iterator& operator++() {
-      typedef typename __rebind_pointer<__node_pointer, typename __node::base>::type
-        __node_base_pointer;
-      __ptr_ = static_cast<__node_pointer>(
-          __tree_next(static_cast<__node_base_pointer>(__ptr_)));
+      __ptr_ = static_cast<__iter_pointer>(
+          __tree_next_iter<__end_node_pointer>(static_cast<__node_base_pointer>(__ptr_)));
       return *this;
     }
 
@@ -710,10 +920,8 @@ public:
 
     _LIBCPP_INLINE_VISIBILITY
     __tree_const_iterator& operator--() {
-      typedef typename __rebind_pointer<__node_pointer, typename __node::base>::type
-        __node_base_pointer;
-      __ptr_ = static_cast<__node_pointer>(
-          __tree_prev(static_cast<__node_base_pointer>(__ptr_)));
+      __ptr_ = static_cast<__iter_pointer>(__tree_prev_iter<__node_base_pointer>(
+          static_cast<__end_node_pointer>(__ptr_)));
       return *this;
     }
 
@@ -732,12 +940,19 @@ private:
     _LIBCPP_INLINE_VISIBILITY
     explicit __tree_const_iterator(__node_pointer __p) _NOEXCEPT
         : __ptr_(__p) {}
+    _LIBCPP_INLINE_VISIBILITY
+    explicit __tree_const_iterator(__end_node_pointer __p) _NOEXCEPT
+        : __ptr_(__p) {}
+    _LIBCPP_INLINE_VISIBILITY
+    __node_pointer __get_np() const { return static_cast<__node_pointer>(__ptr_); }
+
     template <class, class, class> friend class __tree;
     template <class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY map;
     template <class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY multimap;
     template <class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY set;
     template <class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY multiset;
     template <class> friend class _LIBCPP_TYPE_VIS_ONLY __map_const_iterator;
+
 };
 
 template <class _Tp, class _Compare, class _Allocator>
@@ -747,48 +962,73 @@ public:
     typedef _Tp                                      value_type;
     typedef _Compare                                 value_compare;
     typedef _Allocator                               allocator_type;
+
+private:
     typedef allocator_traits<allocator_type>         __alloc_traits;
+    typedef typename __make_tree_node_types<value_type,
+        typename __alloc_traits::void_pointer>::type
+                                                    _NodeTypes;
+    typedef typename _NodeTypes::key_type           key_type;
+public:
+    typedef typename _NodeTypes::__node_value_type      __node_value_type;
+    typedef typename _NodeTypes::__container_value_type __container_value_type;
+
     typedef typename __alloc_traits::pointer         pointer;
     typedef typename __alloc_traits::const_pointer   const_pointer;
     typedef typename __alloc_traits::size_type       size_type;
     typedef typename __alloc_traits::difference_type difference_type;
 
-    typedef typename __alloc_traits::void_pointer  __void_pointer;
+public:
+    typedef typename _NodeTypes::__void_pointer        __void_pointer;
+
+    typedef typename _NodeTypes::__node_type           __node;
+    typedef typename _NodeTypes::__node_pointer        __node_pointer;
+
+    typedef typename _NodeTypes::__node_base_type      __node_base;
+    typedef typename _NodeTypes::__node_base_pointer   __node_base_pointer;
+
+    typedef typename _NodeTypes::__end_node_type       __end_node_t;
+    typedef typename _NodeTypes::__end_node_pointer    __end_node_ptr;
+
+    typedef typename _NodeTypes::__parent_pointer      __parent_pointer;
+    typedef typename _NodeTypes::__iter_pointer        __iter_pointer;
 
-    typedef __tree_node<value_type, __void_pointer> __node;
-    typedef __tree_node_base<__void_pointer>        __node_base;
     typedef typename __rebind_alloc_helper<__alloc_traits, __node>::type __node_allocator;
-    typedef allocator_traits<__node_allocator>       __node_traits;
-    typedef typename __node_traits::pointer          __node_pointer;
-    typedef typename __node_traits::pointer          __node_const_pointer;
-    typedef typename __node_base::pointer            __node_base_pointer;
-    typedef typename __node_base::pointer            __node_base_const_pointer;
+    typedef allocator_traits<__node_allocator>         __node_traits;
+
 private:
-    typedef typename __node_base::base __end_node_t;
-    typedef typename __rebind_pointer<__node_pointer, __end_node_t>::type
-        __end_node_ptr;
-    typedef __end_node_ptr __end_node_const_ptr;
+    // check for sane allocator pointer rebinding semantics. Rebinding the
+    // allocator for a new pointer type should be exactly the same as rebinding
+    // the pointer using 'pointer_traits'.
+    static_assert((is_same<__node_pointer, typename __node_traits::pointer>::value),
+                  "Allocator does not rebind pointers in a sane manner.");
+    typedef typename __rebind_alloc_helper<__node_traits, __node_base>::type
+        __node_base_allocator;
+    typedef allocator_traits<__node_base_allocator> __node_base_traits;
+    static_assert((is_same<__node_base_pointer, typename __node_base_traits::pointer>::value),
+                 "Allocator does not rebind pointers in a sane manner.");
 
-    __node_pointer                                          __begin_node_;
+private:
+    __iter_pointer                                     __begin_node_;
     __compressed_pair<__end_node_t, __node_allocator>  __pair1_;
     __compressed_pair<size_type, value_compare>        __pair3_;
 
 public:
     _LIBCPP_INLINE_VISIBILITY
-    __node_pointer __end_node() _NOEXCEPT
+    __iter_pointer __end_node() _NOEXCEPT
     {
-        return static_cast<__node_pointer>
-               (
-                   pointer_traits<__end_node_ptr>::pointer_to(__pair1_.first())
-               );
+        return static_cast<__iter_pointer>(
+                pointer_traits<__end_node_ptr>::pointer_to(__pair1_.first())
+        );
     }
     _LIBCPP_INLINE_VISIBILITY
-    __node_const_pointer __end_node() const _NOEXCEPT
+    __iter_pointer __end_node() const _NOEXCEPT
     {
-        return static_cast<__node_const_pointer>
-               (
-                   pointer_traits<__end_node_const_ptr>::pointer_to(const_cast<__end_node_t&>(__pair1_.first()))
-               );
+        return static_cast<__iter_pointer>(
+            pointer_traits<__end_node_ptr>::pointer_to(
+                const_cast<__end_node_t&>(__pair1_.first())
+            )
+        );
     }
     _LIBCPP_INLINE_VISIBILITY
           __node_allocator& __node_alloc() _NOEXCEPT {return __pair1_.second();}
@@ -797,9 +1037,9 @@ private:
     const __node_allocator& __node_alloc() const _NOEXCEPT
         {return __pair1_.second();}
     _LIBCPP_INLINE_VISIBILITY
-          __node_pointer& __begin_node() _NOEXCEPT {return __begin_node_;}
+          __iter_pointer& __begin_node() _NOEXCEPT {return __begin_node_;}
     _LIBCPP_INLINE_VISIBILITY
-    const __node_pointer& __begin_node() const _NOEXCEPT {return __begin_node_;}
+    const __iter_pointer& __begin_node() const _NOEXCEPT {return __begin_node_;}
 public:
     _LIBCPP_INLINE_VISIBILITY
     allocator_type __alloc() const _NOEXCEPT
@@ -816,12 +1056,14 @@ public:
     const value_compare& value_comp() const _NOEXCEPT
         {return __pair3_.second();}
 public:
+
     _LIBCPP_INLINE_VISIBILITY
-    __node_pointer __root() _NOEXCEPT
-        {return static_cast<__node_pointer>      (__end_node()->__left_);}
-    _LIBCPP_INLINE_VISIBILITY
-    __node_const_pointer __root() const _NOEXCEPT
-        {return static_cast<__node_const_pointer>(__end_node()->__left_);}
+    __node_pointer __root() const _NOEXCEPT
+        {return static_cast<__node_pointer>(__end_node()->__left_);}
+
+    __node_base_pointer* __root_ptr() const _NOEXCEPT {
+        return _VSTD::addressof(__end_node()->__left_);
+    }
 
     typedef __tree_iterator<value_type, __node_pointer, difference_type>             iterator;
     typedef __tree_const_iterator<value_type, __node_pointer, difference_type> const_iterator;
@@ -877,45 +1119,195 @@ public:
 #endif
             );
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#ifndef _LIBCPP_HAS_NO_VARIADICS
+
+#ifndef _LIBCPP_CXX03_LANG
+    template <class _Key, class ..._Args>
+    pair<iterator, bool>
+    __emplace_unique_key_args(_Key const&, _Args&&... __args);
+    template <class _Key, class ..._Args>
+    iterator
+    __emplace_hint_unique_key_args(const_iterator, _Key const&, _Args&&...);
+
     template <class... _Args>
-        pair<iterator, bool>
-        __emplace_unique(_Args&&... __args);
+    pair<iterator, bool> __emplace_unique_impl(_Args&&... __args);
+
     template <class... _Args>
-        iterator
-        __emplace_multi(_Args&&... __args);
+    iterator __emplace_hint_unique_impl(const_iterator __p, _Args&&... __args);
 
     template <class... _Args>
-        iterator
-        __emplace_hint_unique(const_iterator __p, _Args&&... __args);
+    iterator __emplace_multi(_Args&&... __args);
+
     template <class... _Args>
+    iterator __emplace_hint_multi(const_iterator __p, _Args&&... __args);
+
+    template <class _Pp>
+    _LIBCPP_INLINE_VISIBILITY
+    pair<iterator, bool> __emplace_unique(_Pp&& __x) {
+        return __emplace_unique_extract_key(_VSTD::forward<_Pp>(__x),
+                                            __can_extract_key<_Pp, key_type>());
+    }
+
+    template <class _First, class _Second>
+    _LIBCPP_INLINE_VISIBILITY
+    typename enable_if<
+        __can_extract_map_key<_First, key_type, __container_value_type>::value,
+        pair<iterator, bool>
+    >::type __emplace_unique(_First&& __f, _Second&& __s) {
+        return __emplace_unique_key_args(__f, _VSTD::forward<_First>(__f),
+                                              _VSTD::forward<_Second>(__s));
+    }
+
+    template <class... _Args>
+    _LIBCPP_INLINE_VISIBILITY
+    pair<iterator, bool> __emplace_unique(_Args&&... __args) {
+        return __emplace_unique_impl(_VSTD::forward<_Args>(__args)...);
+    }
+
+    template <class _Pp>
+    _LIBCPP_INLINE_VISIBILITY
+    pair<iterator, bool>
+    __emplace_unique_extract_key(_Pp&& __x, __extract_key_fail_tag) {
+      return __emplace_unique_impl(_VSTD::forward<_Pp>(__x));
+    }
+
+    template <class _Pp>
+    _LIBCPP_INLINE_VISIBILITY
+    pair<iterator, bool>
+    __emplace_unique_extract_key(_Pp&& __x, __extract_key_self_tag) {
+      return __emplace_unique_key_args(__x, _VSTD::forward<_Pp>(__x));
+    }
+
+    template <class _Pp>
+    _LIBCPP_INLINE_VISIBILITY
+    pair<iterator, bool>
+    __emplace_unique_extract_key(_Pp&& __x, __extract_key_first_tag) {
+      return __emplace_unique_key_args(__x.first, _VSTD::forward<_Pp>(__x));
+    }
+
+    template <class _Pp>
+    _LIBCPP_INLINE_VISIBILITY
+    iterator __emplace_hint_unique(const_iterator __p, _Pp&& __x) {
+        return __emplace_hint_unique_extract_key(__p, _VSTD::forward<_Pp>(__x),
+                                            __can_extract_key<_Pp, key_type>());
+    }
+
+    template <class _First, class _Second>
+    _LIBCPP_INLINE_VISIBILITY
+    typename enable_if<
+        __can_extract_map_key<_First, key_type, __container_value_type>::value,
         iterator
-        __emplace_hint_multi(const_iterator __p, _Args&&... __args);
-#endif  // _LIBCPP_HAS_NO_VARIADICS
+    >::type __emplace_hint_unique(const_iterator __p, _First&& __f, _Second&& __s) {
+        return __emplace_hint_unique_key_args(__p, __f,
+                                              _VSTD::forward<_First>(__f),
+                                              _VSTD::forward<_Second>(__s));
+    }
 
-    template <class _Vp>
-        pair<iterator, bool> __insert_unique(_Vp&& __v);
-    template <class _Vp>
-        iterator __insert_unique(const_iterator __p, _Vp&& __v);
-    template <class _Vp>
-        iterator __insert_multi(_Vp&& __v);
-    template <class _Vp>
-        iterator __insert_multi(const_iterator __p, _Vp&& __v);
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    template <class... _Args>
+    _LIBCPP_INLINE_VISIBILITY
+    iterator __emplace_hint_unique(const_iterator __p, _Args&&... __args) {
+        return __emplace_hint_unique_impl(__p, _VSTD::forward<_Args>(__args)...);
+    }
 
-    pair<iterator, bool> __insert_unique(const value_type& __v);
-    iterator __insert_unique(const_iterator __p, const value_type& __v);
-    iterator __insert_multi(const value_type& __v);
-    iterator __insert_multi(const_iterator __p, const value_type& __v);
+    template <class _Pp>
+    _LIBCPP_INLINE_VISIBILITY
+    iterator
+    __emplace_hint_unique_extract_key(const_iterator __p, _Pp&& __x, __extract_key_fail_tag) {
+      return __emplace_hint_unique_impl(__p, _VSTD::forward<_Pp>(__x));
+    }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    pair<iterator, bool> __insert_unique(        value_type&& __v);
-    iterator __insert_unique(const_iterator __p, value_type&& __v);
-    iterator __insert_multi(                    value_type&& __v);
-    iterator __insert_multi(const_iterator __p, value_type&& __v);
+    template <class _Pp>
+    _LIBCPP_INLINE_VISIBILITY
+    iterator
+    __emplace_hint_unique_extract_key(const_iterator __p, _Pp&& __x, __extract_key_self_tag) {
+      return __emplace_hint_unique_key_args(__p, __x, _VSTD::forward<_Pp>(__x));
+    }
+
+    template <class _Pp>
+    _LIBCPP_INLINE_VISIBILITY
+    iterator
+    __emplace_hint_unique_extract_key(const_iterator __p, _Pp&& __x, __extract_key_first_tag) {
+      return __emplace_hint_unique_key_args(__p, __x.first, _VSTD::forward<_Pp>(__x));
+    }
+
+#else
+    template <class _Key, class _Args>
+    _LIBCPP_INLINE_VISIBILITY
+    pair<iterator, bool> __emplace_unique_key_args(_Key const&, _Args& __args);
+    template <class _Key, class _Args>
+    _LIBCPP_INLINE_VISIBILITY
+    iterator __emplace_hint_unique_key_args(const_iterator, _Key const&, _Args&);
 #endif
 
+    _LIBCPP_INLINE_VISIBILITY
+    pair<iterator, bool> __insert_unique(const __container_value_type& __v) {
+        return __emplace_unique_key_args(_NodeTypes::__get_key(__v), __v);
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    iterator __insert_unique(const_iterator __p, const __container_value_type& __v) {
+        return __emplace_hint_unique_key_args(__p, _NodeTypes::__get_key(__v), __v);
+    }
+
+#ifdef _LIBCPP_CXX03_LANG
+    _LIBCPP_INLINE_VISIBILITY
+    iterator __insert_multi(const __container_value_type& __v);
+    _LIBCPP_INLINE_VISIBILITY
+    iterator __insert_multi(const_iterator __p, const __container_value_type& __v);
+#else
+    _LIBCPP_INLINE_VISIBILITY
+    pair<iterator, bool> __insert_unique(__container_value_type&& __v) {
+        return __emplace_unique_key_args(_NodeTypes::__get_key(__v), _VSTD::move(__v));
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    iterator __insert_unique(const_iterator __p, __container_value_type&& __v) {
+        return __emplace_hint_unique_key_args(__p, _NodeTypes::__get_key(__v), _VSTD::move(__v));
+    }
+
+    template <class _Vp, class = typename enable_if<
+            !is_same<typename __unconstref<_Vp>::type,
+                     __container_value_type
+            >::value
+        >::type>
+    _LIBCPP_INLINE_VISIBILITY
+    pair<iterator, bool> __insert_unique(_Vp&& __v) {
+        return __emplace_unique(_VSTD::forward<_Vp>(__v));
+    }
+
+    template <class _Vp, class = typename enable_if<
+            !is_same<typename __unconstref<_Vp>::type,
+                     __container_value_type
+            >::value
+        >::type>
+    _LIBCPP_INLINE_VISIBILITY
+    iterator __insert_unique(const_iterator __p, _Vp&& __v) {
+        return __emplace_hint_unique(__p, _VSTD::forward<_Vp>(__v));
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    iterator __insert_multi(__container_value_type&& __v) {
+        return __emplace_multi(_VSTD::move(__v));
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    iterator __insert_multi(const_iterator __p, __container_value_type&& __v) {
+        return __emplace_hint_multi(__p, _VSTD::move(__v));
+    }
+
+    template <class _Vp>
+    _LIBCPP_INLINE_VISIBILITY
+    iterator __insert_multi(_Vp&& __v) {
+        return __emplace_multi(_VSTD::forward<_Vp>(__v));
+    }
+
+    template <class _Vp>
+    _LIBCPP_INLINE_VISIBILITY
+    iterator __insert_multi(const_iterator __p, _Vp&& __v) {
+        return __emplace_hint_multi(__p, _VSTD::forward<_Vp>(__v));
+    }
+
+#endif // !_LIBCPP_CXX03_LANG
+
     pair<iterator, bool> __node_insert_unique(__node_pointer __nd);
     iterator             __node_insert_unique(const_iterator __p,
                                               __node_pointer __nd);
@@ -930,7 +1322,7 @@ public:
     template <class _Key>
         size_type __erase_multi(const _Key& __k);
 
-    void __insert_node_at(__node_base_pointer __parent,
+    void __insert_node_at(__parent_pointer     __parent,
                           __node_base_pointer& __child,
                           __node_base_pointer __new_node);
 
@@ -951,15 +1343,15 @@ public:
     template <class _Key>
         iterator __lower_bound(const _Key& __v,
                                __node_pointer __root,
-                               __node_pointer __result);
+                               __iter_pointer __result);
     template <class _Key>
         _LIBCPP_INLINE_VISIBILITY
         const_iterator lower_bound(const _Key& __v) const
             {return __lower_bound(__v, __root(), __end_node());}
     template <class _Key>
         const_iterator __lower_bound(const _Key& __v,
-                                     __node_const_pointer __root,
-                                     __node_const_pointer __result) const;
+                                     __node_pointer __root,
+                                     __iter_pointer __result) const;
     template <class _Key>
         _LIBCPP_INLINE_VISIBILITY
         iterator upper_bound(const _Key& __v)
@@ -967,15 +1359,15 @@ public:
     template <class _Key>
         iterator __upper_bound(const _Key& __v,
                                __node_pointer __root,
-                               __node_pointer __result);
+                               __iter_pointer __result);
     template <class _Key>
         _LIBCPP_INLINE_VISIBILITY
         const_iterator upper_bound(const _Key& __v) const
             {return __upper_bound(__v, __root(), __end_node());}
     template <class _Key>
         const_iterator __upper_bound(const _Key& __v,
-                                     __node_const_pointer __root,
-                                     __node_const_pointer __result) const;
+                                     __node_pointer __root,
+                                     __iter_pointer __result) const;
     template <class _Key>
         pair<iterator, iterator>
         __equal_range_unique(const _Key& __k);
@@ -995,26 +1387,27 @@ public:
 
     __node_holder remove(const_iterator __p) _NOEXCEPT;
 private:
-    typename __node_base::pointer&
-        __find_leaf_low(typename __node_base::pointer& __parent, const value_type& __v);
-    typename __node_base::pointer&
-        __find_leaf_high(typename __node_base::pointer& __parent, const value_type& __v);
-    typename __node_base::pointer&
+    __node_base_pointer&
+        __find_leaf_low(__parent_pointer& __parent, const key_type& __v);
+    __node_base_pointer&
+        __find_leaf_high(__parent_pointer& __parent, const key_type& __v);
+    __node_base_pointer&
         __find_leaf(const_iterator __hint,
-                    typename __node_base::pointer& __parent, const value_type& __v);
+                    __parent_pointer& __parent, const key_type& __v);
     template <class _Key>
-        typename __node_base::pointer&
-        __find_equal(typename __node_base::pointer& __parent, const _Key& __v);
+    __node_base_pointer&
+        __find_equal(__parent_pointer& __parent, const _Key& __v);
     template <class _Key>
-        typename __node_base::pointer&
-        __find_equal(const_iterator __hint, typename __node_base::pointer& __parent,
+    __node_base_pointer&
+        __find_equal(const_iterator __hint, __parent_pointer& __parent,
+                     __node_base_pointer& __dummy,
                      const _Key& __v);
 
-#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
+#ifndef _LIBCPP_CXX03_LANG
     template <class ..._Args>
-        __node_holder __construct_node(_Args&& ...__args);
-#else  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
-        __node_holder __construct_node(const value_type& __v);
+    __node_holder __construct_node(_Args&& ...__args);
+#else
+    __node_holder __construct_node(const __container_value_type& __v);
 #endif
 
     void destroy(__node_pointer __nd) _NOEXCEPT;
@@ -1069,7 +1462,7 @@ __tree<_Tp, _Compare, _Allocator>::__tree(const value_compare& __comp)
 
 template <class _Tp, class _Compare, class _Allocator>
 __tree<_Tp, _Compare, _Allocator>::__tree(const allocator_type& __a)
-    : __begin_node_(__node_pointer()),
+    : __begin_node_(__iter_pointer()),
       __pair1_(__node_allocator(__a)),
       __pair3_(0)
 {
@@ -1079,7 +1472,7 @@ __tree<_Tp, _Compare, _Allocator>::__tree(const allocator_type& __a)
 template <class _Tp, class _Compare, class _Allocator>
 __tree<_Tp, _Compare, _Allocator>::__tree(const value_compare& __comp,
                                            const allocator_type& __a)
-    : __begin_node_(__node_pointer()),
+    : __begin_node_(__iter_pointer()),
       __pair1_(__node_allocator(__a)),
       __pair3_(0, __comp)
 {
@@ -1091,7 +1484,7 @@ template <class _Tp, class _Compare, class _Allocator>
 typename __tree<_Tp, _Compare, _Allocator>::__node_pointer
 __tree<_Tp, _Compare, _Allocator>::__detach()
 {
-    __node_pointer __cache = __begin_node();
+    __node_pointer __cache = static_cast<__node_pointer>(__begin_node());
     __begin_node() = __end_node();
     __end_node()->__left_->__parent_ = nullptr;
     __end_node()->__left_ = nullptr;
@@ -1123,7 +1516,7 @@ __tree<_Tp, _Compare, _Allocator>::__detach(__node_pointer __cache)
         return static_cast<__node_pointer>(__tree_leaf(__cache->__right_));
     }
     // __cache is right child
-    __cache->__parent_->__right_ = nullptr;
+    __cache->__parent_unsafe()->__right_ = nullptr;
     __cache = static_cast<__node_pointer>(__cache->__parent_);
     if (__cache->__left_ == nullptr)
         return __cache;
@@ -1148,6 +1541,11 @@ template <class _InputIterator>
 void
 __tree<_Tp, _Compare, _Allocator>::__assign_unique(_InputIterator __first, _InputIterator __last)
 {
+    typedef iterator_traits<_InputIterator> _ITraits;
+    typedef typename _ITraits::value_type _ItValueType;
+    static_assert((is_same<_ItValueType, __container_value_type>::value),
+                  "__assign_unique may only be called with the containers value type");
+
     if (size() != 0)
     {
         __node_pointer __cache = __detach();
@@ -1188,6 +1586,12 @@ template <class _InputIterator>
 void
 __tree<_Tp, _Compare, _Allocator>::__assign_multi(_InputIterator __first, _InputIterator __last)
 {
+    typedef iterator_traits<_InputIterator> _ITraits;
+    typedef typename _ITraits::value_type _ItValueType;
+    static_assert((is_same<_ItValueType, __container_value_type>::value ||
+                  is_same<_ItValueType, __node_value_type>::value),
+                  "__assign_multi may only be called with the containers value type"
+                  " or the nodes value type");
     if (size() != 0)
     {
         __node_pointer __cache = __detach();
@@ -1220,12 +1624,12 @@ __tree<_Tp, _Compare, _Allocator>::__assign_multi(_InputIterator __first, _Input
         }
     }
     for (; __first != __last; ++__first)
-        __insert_multi(*__first);
+        __insert_multi(_NodeTypes::__get_value(*__first));
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 __tree<_Tp, _Compare, _Allocator>::__tree(const __tree& __t)
-    : __begin_node_(__node_pointer()),
+    : __begin_node_(__iter_pointer()),
       __pair1_(__node_traits::select_on_container_copy_construction(__t.__node_alloc())),
       __pair3_(0, __t.value_comp())
 {
@@ -1247,7 +1651,7 @@ __tree<_Tp, _Compare, _Allocator>::__tree(__tree&& __t)
         __begin_node() = __end_node();
     else
     {
-        __end_node()->__left_->__parent_ = static_cast<__node_base_pointer>(__end_node());
+        __end_node()->__left_->__parent_ = static_cast<__parent_pointer>(__end_node());
         __t.__begin_node() = __t.__end_node();
         __t.__end_node()->__left_ = nullptr;
         __t.size() = 0;
@@ -1267,7 +1671,7 @@ __tree<_Tp, _Compare, _Allocator>::__tree(__tree&& __t, const allocator_type& __
         {
             __begin_node() = __t.__begin_node();
             __end_node()->__left_ = __t.__end_node()->__left_;
-            __end_node()->__left_->__parent_ = static_cast<__node_base_pointer>(__end_node());
+            __end_node()->__left_->__parent_ = static_cast<__parent_pointer>(__end_node());
             size() = __t.size();
             __t.__begin_node() = __t.__end_node();
             __t.__end_node()->__left_ = nullptr;
@@ -1295,7 +1699,7 @@ __tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, true_type)
         __begin_node() = __end_node();
     else
     {
-        __end_node()->__left_->__parent_ = static_cast<__node_base_pointer>(__end_node());
+        __end_node()->__left_->__parent_ = static_cast<__parent_pointer>(__end_node());
         __t.__begin_node() = __t.__end_node();
         __t.__end_node()->__left_ = nullptr;
         __t.size() = 0;
@@ -1344,7 +1748,7 @@ __tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, false_type)
             }
         }
         while (__t.size() != 0)
-            __insert_multi(__e, _VSTD::move(__t.remove(__t.begin())->__value_));
+            __insert_multi(__e, _NodeTypes::__move(__t.remove(__t.begin())->__value_));
     }
 }
 
@@ -1367,6 +1771,8 @@ __tree<_Tp, _Compare, _Allocator>::operator=(__tree&& __t)
 template <class _Tp, class _Compare, class _Allocator>
 __tree<_Tp, _Compare, _Allocator>::~__tree()
 {
+    static_assert((is_copy_constructible<value_compare>::value),
+                 "Comparator must be copy-constructible.");
     destroy(__root());
 }
 
@@ -1379,7 +1785,7 @@ __tree<_Tp, _Compare, _Allocator>::destroy(__node_pointer __nd) _NOEXCEPT
         destroy(static_cast<__node_pointer>(__nd->__left_));
         destroy(static_cast<__node_pointer>(__nd->__right_));
         __node_allocator& __na = __node_alloc();
-        __node_traits::destroy(__na, _VSTD::addressof(__nd->__value_));
+        __node_traits::destroy(__na, _NodeTypes::__get_ptr(__nd->__value_));
         __node_traits::deallocate(__na, __nd, 1);
     }
 }
@@ -1403,11 +1809,11 @@ __tree<_Tp, _Compare, _Allocator>::swap(__tree& __t)
     if (size() == 0)
         __begin_node() = __end_node();
     else
-        __end_node()->__left_->__parent_ = static_cast<__node_base_pointer>(__end_node());
+        __end_node()->__left_->__parent_ = static_cast<__parent_pointer>(__end_node());
     if (__t.size() == 0)
         __t.__begin_node() = __t.__end_node();
     else
-        __t.__end_node()->__left_->__parent_ = static_cast<__node_base_pointer>(__t.__end_node());
+        __t.__end_node()->__left_->__parent_ = static_cast<__parent_pointer>(__t.__end_node());
 }
 
 template <class _Tp, class _Compare, class _Allocator>
@@ -1424,9 +1830,9 @@ __tree<_Tp, _Compare, _Allocator>::clear() _NOEXCEPT
 // Set __parent to parent of null leaf
 // Return reference to null leaf
 template <class _Tp, class _Compare, class _Allocator>
-typename __tree<_Tp, _Compare, _Allocator>::__node_base::pointer&
-__tree<_Tp, _Compare, _Allocator>::__find_leaf_low(typename __node_base::pointer& __parent,
-                                                   const value_type& __v)
+typename __tree<_Tp, _Compare, _Allocator>::__node_base_pointer&
+__tree<_Tp, _Compare, _Allocator>::__find_leaf_low(__parent_pointer& __parent,
+                                                   const key_type& __v)
 {
     __node_pointer __nd = __root();
     if (__nd != nullptr)
@@ -1439,8 +1845,8 @@ __tree<_Tp, _Compare, _Allocator>::__find_leaf_low(typename __node_base::pointer
                     __nd = static_cast<__node_pointer>(__nd->__right_);
                 else
                 {
-                    __parent = static_cast<__node_base_pointer>(__nd);
-                    return __parent->__right_;
+                    __parent = static_cast<__parent_pointer>(__nd);
+                    return __nd->__right_;
                 }
             }
             else
@@ -1449,13 +1855,13 @@ __tree<_Tp, _Compare, _Allocator>::__find_leaf_low(typename __node_base::pointer
                     __nd = static_cast<__node_pointer>(__nd->__left_);
                 else
                 {
-                    __parent = static_cast<__node_base_pointer>(__nd);
+                    __parent = static_cast<__parent_pointer>(__nd);
                     return __parent->__left_;
                 }
             }
         }
     }
-    __parent = static_cast<__node_base_pointer>(__end_node());
+    __parent = static_cast<__parent_pointer>(__end_node());
     return __parent->__left_;
 }
 
@@ -1463,9 +1869,9 @@ __tree<_Tp, _Compare, _Allocator>::__find_leaf_low(typename __node_base::pointer
 // Set __parent to parent of null leaf
 // Return reference to null leaf
 template <class _Tp, class _Compare, class _Allocator>
-typename __tree<_Tp, _Compare, _Allocator>::__node_base::pointer&
-__tree<_Tp, _Compare, _Allocator>::__find_leaf_high(typename __node_base::pointer& __parent,
-                                                    const value_type& __v)
+typename __tree<_Tp, _Compare, _Allocator>::__node_base_pointer&
+__tree<_Tp, _Compare, _Allocator>::__find_leaf_high(__parent_pointer& __parent,
+                                                    const key_type& __v)
 {
     __node_pointer __nd = __root();
     if (__nd != nullptr)
@@ -1478,7 +1884,7 @@ __tree<_Tp, _Compare, _Allocator>::__find_leaf_high(typename __node_base::pointe
                     __nd = static_cast<__node_pointer>(__nd->__left_);
                 else
                 {
-                    __parent = static_cast<__node_base_pointer>(__nd);
+                    __parent = static_cast<__parent_pointer>(__nd);
                     return __parent->__left_;
                 }
             }
@@ -1488,13 +1894,13 @@ __tree<_Tp, _Compare, _Allocator>::__find_leaf_high(typename __node_base::pointe
                     __nd = static_cast<__node_pointer>(__nd->__right_);
                 else
                 {
-                    __parent = static_cast<__node_base_pointer>(__nd);
-                    return __parent->__right_;
+                    __parent = static_cast<__parent_pointer>(__nd);
+                    return __nd->__right_;
                 }
             }
         }
     }
-    __parent = static_cast<__node_base_pointer>(__end_node());
+    __parent = static_cast<__parent_pointer>(__end_node());
     return __parent->__left_;
 }
 
@@ -1505,10 +1911,10 @@ __tree<_Tp, _Compare, _Allocator>::__find_leaf_high(typename __node_base::pointe
 // Set __parent to parent of null leaf
 // Return reference to null leaf
 template <class _Tp, class _Compare, class _Allocator>
-typename __tree<_Tp, _Compare, _Allocator>::__node_base::pointer&
+typename __tree<_Tp, _Compare, _Allocator>::__node_base_pointer&
 __tree<_Tp, _Compare, _Allocator>::__find_leaf(const_iterator __hint,
-                                               typename __node_base::pointer& __parent,
-                                               const value_type& __v)
+                                               __parent_pointer& __parent,
+                                               const key_type& __v)
 {
     if (__hint == end() || !value_comp()(*__hint, __v))  // check before
     {
@@ -1519,13 +1925,13 @@ __tree<_Tp, _Compare, _Allocator>::__find_leaf(const_iterator __hint,
             // *prev(__hint) <= __v <= *__hint
             if (__hint.__ptr_->__left_ == nullptr)
             {
-                __parent = static_cast<__node_base_pointer>(__hint.__ptr_);
+                __parent = static_cast<__parent_pointer>(__hint.__ptr_);
                 return __parent->__left_;
             }
             else
             {
-                __parent = static_cast<__node_base_pointer>(__prior.__ptr_);
-                return __parent->__right_;
+                __parent = static_cast<__parent_pointer>(__prior.__ptr_);
+                return static_cast<__node_base_pointer>(__prior.__ptr_)->__right_;
             }
         }
         // __v < *prev(__hint)
@@ -1541,43 +1947,44 @@ __tree<_Tp, _Compare, _Allocator>::__find_leaf(const_iterator __hint,
 // If __v exists, set parent to node of __v and return reference to node of __v
 template <class _Tp, class _Compare, class _Allocator>
 template <class _Key>
-typename __tree<_Tp, _Compare, _Allocator>::__node_base::pointer&
-__tree<_Tp, _Compare, _Allocator>::__find_equal(typename __node_base::pointer& __parent,
+typename __tree<_Tp, _Compare, _Allocator>::__node_base_pointer&
+__tree<_Tp, _Compare, _Allocator>::__find_equal(__parent_pointer& __parent,
                                                 const _Key& __v)
 {
     __node_pointer __nd = __root();
+    __node_base_pointer* __nd_ptr = __root_ptr();
     if (__nd != nullptr)
     {
         while (true)
         {
             if (value_comp()(__v, __nd->__value_))
             {
-                if (__nd->__left_ != nullptr)
+                if (__nd->__left_ != nullptr) {
+                    __nd_ptr = _VSTD::addressof(__nd->__left_);
                     __nd = static_cast<__node_pointer>(__nd->__left_);
-                else
-                {
-                    __parent = static_cast<__node_base_pointer>(__nd);
+                } else {
+                    __parent = static_cast<__parent_pointer>(__nd);
                     return __parent->__left_;
                 }
             }
             else if (value_comp()(__nd->__value_, __v))
             {
-                if (__nd->__right_ != nullptr)
+                if (__nd->__right_ != nullptr) {
+                    __nd_ptr = _VSTD::addressof(__nd->__right_);
                     __nd = static_cast<__node_pointer>(__nd->__right_);
-                else
-                {
-                    __parent = static_cast<__node_base_pointer>(__nd);
-                    return __parent->__right_;
+                } else {
+                    __parent = static_cast<__parent_pointer>(__nd);
+                    return __nd->__right_;
                 }
             }
             else
             {
-                __parent = static_cast<__node_base_pointer>(__nd);
-                return __parent;
+                __parent = static_cast<__parent_pointer>(__nd);
+                return *__nd_ptr;
             }
         }
     }
-    __parent = static_cast<__node_base_pointer>(__end_node());
+    __parent = static_cast<__parent_pointer>(__end_node());
     return __parent->__left_;
 }
 
@@ -1590,9 +1997,10 @@ __tree<_Tp, _Compare, _Allocator>::__find_equal(typename __node_base::pointer& _
 // If __v exists, set parent to node of __v and return reference to node of __v
 template <class _Tp, class _Compare, class _Allocator>
 template <class _Key>
-typename __tree<_Tp, _Compare, _Allocator>::__node_base::pointer&
+typename __tree<_Tp, _Compare, _Allocator>::__node_base_pointer&
 __tree<_Tp, _Compare, _Allocator>::__find_equal(const_iterator __hint,
-                                                typename __node_base::pointer& __parent,
+                                                __parent_pointer& __parent,
+                                                __node_base_pointer& __dummy,
                                                 const _Key& __v)
 {
     if (__hint == end() || value_comp()(__v, *__hint))  // check before
@@ -1604,13 +2012,13 @@ __tree<_Tp, _Compare, _Allocator>::__find_equal(const_iterator __hint,
             // *prev(__hint) < __v < *__hint
             if (__hint.__ptr_->__left_ == nullptr)
             {
-                __parent = static_cast<__node_base_pointer>(__hint.__ptr_);
+                __parent = static_cast<__parent_pointer>(__hint.__ptr_);
                 return __parent->__left_;
             }
             else
             {
-                __parent = static_cast<__node_base_pointer>(__prior.__ptr_);
-                return __parent->__right_;
+                __parent = static_cast<__parent_pointer>(__prior.__ptr_);
+                return static_cast<__node_base_pointer>(__prior.__ptr_)->__right_;
             }
         }
         // __v <= *prev(__hint)
@@ -1623,14 +2031,14 @@ __tree<_Tp, _Compare, _Allocator>::__find_equal(const_iterator __hint,
         if (__next == end() || value_comp()(__v, *__next))
         {
             // *__hint < __v < *_VSTD::next(__hint)
-            if (__hint.__ptr_->__right_ == nullptr)
+            if (__hint.__get_np()->__right_ == nullptr)
             {
-                __parent = static_cast<__node_base_pointer>(__hint.__ptr_);
-                return __parent->__right_;
+                __parent = static_cast<__parent_pointer>(__hint.__ptr_);
+                return static_cast<__node_base_pointer>(__hint.__ptr_)->__right_;
             }
             else
             {
-                __parent = static_cast<__node_base_pointer>(__next.__ptr_);
+                __parent = static_cast<__parent_pointer>(__next.__ptr_);
                 return __parent->__left_;
             }
         }
@@ -1638,48 +2046,115 @@ __tree<_Tp, _Compare, _Allocator>::__find_equal(const_iterator __hint,
         return __find_equal(__parent, __v);
     }
     // else __v == *__hint
-    __parent = static_cast<__node_base_pointer>(__hint.__ptr_);
-    return __parent;
+    __parent = static_cast<__parent_pointer>(__hint.__ptr_);
+    __dummy = static_cast<__node_base_pointer>(__hint.__ptr_);
+    return __dummy;
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 void
-__tree<_Tp, _Compare, _Allocator>::__insert_node_at(__node_base_pointer __parent,
+__tree<_Tp, _Compare, _Allocator>::__insert_node_at(__parent_pointer     __parent,
                                                     __node_base_pointer& __child,
-                                                    __node_base_pointer __new_node)
+                                                    __node_base_pointer  __new_node)
 {
     __new_node->__left_   = nullptr;
     __new_node->__right_  = nullptr;
     __new_node->__parent_ = __parent;
+    // __new_node->__is_black_ is initialized in __tree_balance_after_insert
     __child = __new_node;
     if (__begin_node()->__left_ != nullptr)
-        __begin_node() = static_cast<__node_pointer>(__begin_node()->__left_);
+        __begin_node() = static_cast<__iter_pointer>(__begin_node()->__left_);
     __tree_balance_after_insert(__end_node()->__left_, __child);
     ++size();
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#ifndef _LIBCPP_HAS_NO_VARIADICS
+#ifndef _LIBCPP_CXX03_LANG
+template <class _Tp, class _Compare, class _Allocator>
+template <class _Key, class... _Args>
+pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
+__tree<_Tp, _Compare, _Allocator>::__emplace_unique_key_args(_Key const& __k, _Args&&... __args)
+#else
+template <class _Tp, class _Compare, class _Allocator>
+template <class _Key, class _Args>
+pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
+__tree<_Tp, _Compare, _Allocator>::__emplace_unique_key_args(_Key const& __k, _Args& __args)
+#endif
+{
+    __parent_pointer __parent;
+    __node_base_pointer& __child = __find_equal(__parent, __k);
+    __node_pointer __r = static_cast<__node_pointer>(__child);
+    bool __inserted = false;
+    if (__child == nullptr)
+    {
+#ifndef _LIBCPP_CXX03_LANG
+        __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
+#else
+        __node_holder __h = __construct_node(__args);
+#endif
+        __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
+        __r = __h.release();
+        __inserted = true;
+    }
+    return pair<iterator, bool>(iterator(__r), __inserted);
+}
+
+
+#ifndef _LIBCPP_CXX03_LANG
+template <class _Tp, class _Compare, class _Allocator>
+template <class _Key, class... _Args>
+typename __tree<_Tp, _Compare, _Allocator>::iterator
+__tree<_Tp, _Compare, _Allocator>::__emplace_hint_unique_key_args(
+    const_iterator __p, _Key const& __k, _Args&&... __args)
+#else
+template <class _Tp, class _Compare, class _Allocator>
+template <class _Key, class _Args>
+typename __tree<_Tp, _Compare, _Allocator>::iterator
+__tree<_Tp, _Compare, _Allocator>::__emplace_hint_unique_key_args(
+    const_iterator __p, _Key const& __k, _Args& __args)
+#endif
+{
+    __parent_pointer __parent;
+    __node_base_pointer __dummy;
+    __node_base_pointer& __child = __find_equal(__p, __parent, __dummy, __k);
+    __node_pointer __r = static_cast<__node_pointer>(__child);
+    if (__child == nullptr)
+    {
+#ifndef _LIBCPP_CXX03_LANG
+        __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
+#else
+        __node_holder __h = __construct_node(__args);
+#endif
+        __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
+        __r = __h.release();
+    }
+    return iterator(__r);
+}
+
+
+#ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Compare, class _Allocator>
 template <class ..._Args>
 typename __tree<_Tp, _Compare, _Allocator>::__node_holder
 __tree<_Tp, _Compare, _Allocator>::__construct_node(_Args&& ...__args)
 {
+    static_assert(!__is_tree_value_type<_Args...>::value,
+                  "Cannot construct from __value_type");
     __node_allocator& __na = __node_alloc();
     __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
-    __node_traits::construct(__na, _VSTD::addressof(__h->__value_), _VSTD::forward<_Args>(__args)...);
+    __node_traits::construct(__na, _NodeTypes::__get_ptr(__h->__value_), _VSTD::forward<_Args>(__args)...);
     __h.get_deleter().__value_constructed = true;
     return __h;
 }
 
+
 template <class _Tp, class _Compare, class _Allocator>
 template <class... _Args>
 pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
-__tree<_Tp, _Compare, _Allocator>::__emplace_unique(_Args&&... __args)
+__tree<_Tp, _Compare, _Allocator>::__emplace_unique_impl(_Args&&... __args)
 {
     __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
-    __node_base_pointer __parent;
+    __parent_pointer __parent;
     __node_base_pointer& __child = __find_equal(__parent, __h->__value_);
     __node_pointer __r = static_cast<__node_pointer>(__child);
     bool __inserted = false;
@@ -1695,11 +2170,12 @@ __tree<_Tp, _Compare, _Allocator>::__emplace_unique(_Args&&... __args)
 template <class _Tp, class _Compare, class _Allocator>
 template <class... _Args>
 typename __tree<_Tp, _Compare, _Allocator>::iterator
-__tree<_Tp, _Compare, _Allocator>::__emplace_hint_unique(const_iterator __p, _Args&&... __args)
+__tree<_Tp, _Compare, _Allocator>::__emplace_hint_unique_impl(const_iterator __p, _Args&&... __args)
 {
     __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
-    __node_base_pointer __parent;
-    __node_base_pointer& __child = __find_equal(__p, __parent, __h->__value_);
+    __parent_pointer __parent;
+    __node_base_pointer __dummy;
+    __node_base_pointer& __child = __find_equal(__p, __parent, __dummy, __h->__value_);
     __node_pointer __r = static_cast<__node_pointer>(__child);
     if (__child == nullptr)
     {
@@ -1715,8 +2191,8 @@ typename __tree<_Tp, _Compare, _Allocator>::iterator
 __tree<_Tp, _Compare, _Allocator>::__emplace_multi(_Args&&... __args)
 {
     __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
-    __node_base_pointer __parent;
-    __node_base_pointer& __child = __find_leaf_high(__parent, __h->__value_);
+    __parent_pointer __parent;
+    __node_base_pointer& __child = __find_leaf_high(__parent, _NodeTypes::__get_key(__h->__value_));
     __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
     return iterator(static_cast<__node_pointer>(__h.release()));
 }
@@ -1728,161 +2204,35 @@ __tree<_Tp, _Compare, _Allocator>::__emplace_hint_multi(const_iterator __p,
                                                         _Args&&... __args)
 {
     __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
-    __node_base_pointer __parent;
-    __node_base_pointer& __child = __find_leaf(__p, __parent, __h->__value_);
+    __parent_pointer __parent;
+    __node_base_pointer& __child = __find_leaf(__p, __parent, _NodeTypes::__get_key(__h->__value_));
     __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
     return iterator(static_cast<__node_pointer>(__h.release()));
 }
 
-#endif  // _LIBCPP_HAS_NO_VARIADICS
 
-template <class _Tp, class _Compare, class _Allocator>
-pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
-__tree<_Tp, _Compare, _Allocator>::__insert_unique(value_type&& __v)
-{
-    __node_holder __h = __construct_node(_VSTD::forward<value_type>(__v));
-    pair<iterator, bool> __r = __node_insert_unique(__h.get());
-    if (__r.second)
-        __h.release();
-    return __r;
-}
-
-template <class _Tp, class _Compare, class _Allocator>
-typename __tree<_Tp, _Compare, _Allocator>::iterator
-__tree<_Tp, _Compare, _Allocator>::__insert_unique(const_iterator __p, value_type&& __v)
-{
-    __node_holder __h = __construct_node(_VSTD::forward<value_type>(__v));
-    iterator __r = __node_insert_unique(__p, __h.get());
-    if (__r.__ptr_ == __h.get())
-        __h.release();
-    return __r;
-}
-
-template <class _Tp, class _Compare, class _Allocator>
-template <class _Vp>
-pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
-__tree<_Tp, _Compare, _Allocator>::__insert_unique(_Vp&& __v)
-{
-    __node_holder __h = __construct_node(_VSTD::forward<_Vp>(__v));
-    pair<iterator, bool> __r = __node_insert_unique(__h.get());
-    if (__r.second)
-        __h.release();
-    return __r;
-}
-
-template <class _Tp, class _Compare, class _Allocator>
-template <class _Vp>
-typename __tree<_Tp, _Compare, _Allocator>::iterator
-__tree<_Tp, _Compare, _Allocator>::__insert_unique(const_iterator __p, _Vp&& __v)
-{
-    __node_holder __h = __construct_node(_VSTD::forward<_Vp>(__v));
-    iterator __r = __node_insert_unique(__p, __h.get());
-    if (__r.__ptr_ == __h.get())
-        __h.release();
-    return __r;
-}
-
-template <class _Tp, class _Compare, class _Allocator>
-typename __tree<_Tp, _Compare, _Allocator>::iterator
-__tree<_Tp, _Compare, _Allocator>::__insert_multi(value_type&& __v)
-{
-    __node_base_pointer __parent;
-    __node_base_pointer& __child = __find_leaf_high(__parent, __v);
-    __node_holder __h = __construct_node(_VSTD::forward<value_type>(__v));
-    __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
-    return iterator(__h.release());
-}
-
-template <class _Tp, class _Compare, class _Allocator>
-typename __tree<_Tp, _Compare, _Allocator>::iterator
-__tree<_Tp, _Compare, _Allocator>::__insert_multi(const_iterator __p, value_type&& __v)
-{
-    __node_base_pointer __parent;
-    __node_base_pointer& __child = __find_leaf(__p, __parent, __v);
-    __node_holder __h = __construct_node(_VSTD::forward<value_type>(__v));
-    __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
-    return iterator(__h.release());
-}
-
-template <class _Tp, class _Compare, class _Allocator>
-template <class _Vp>
-typename __tree<_Tp, _Compare, _Allocator>::iterator
-__tree<_Tp, _Compare, _Allocator>::__insert_multi(_Vp&& __v)
-{
-    __node_holder __h = __construct_node(_VSTD::forward<_Vp>(__v));
-    __node_base_pointer __parent;
-    __node_base_pointer& __child = __find_leaf_high(__parent, __h->__value_);
-    __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
-    return iterator(__h.release());
-}
-
-template <class _Tp, class _Compare, class _Allocator>
-template <class _Vp>
-typename __tree<_Tp, _Compare, _Allocator>::iterator
-__tree<_Tp, _Compare, _Allocator>::__insert_multi(const_iterator __p, _Vp&& __v)
-{
-    __node_holder __h = __construct_node(_VSTD::forward<_Vp>(__v));
-    __node_base_pointer __parent;
-    __node_base_pointer& __child = __find_leaf(__p, __parent, __h->__value_);
-    __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
-    return iterator(__h.release());
-}
-
-#else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#else  // _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Compare, class _Allocator>
 typename __tree<_Tp, _Compare, _Allocator>::__node_holder
-__tree<_Tp, _Compare, _Allocator>::__construct_node(const value_type& __v)
+__tree<_Tp, _Compare, _Allocator>::__construct_node(const __container_value_type& __v)
 {
     __node_allocator& __na = __node_alloc();
     __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
-    __node_traits::construct(__na, _VSTD::addressof(__h->__value_), __v);
+    __node_traits::construct(__na, _NodeTypes::__get_ptr(__h->__value_), __v);
     __h.get_deleter().__value_constructed = true;
     return _LIBCPP_EXPLICIT_MOVE(__h);  // explicitly moved for C++03
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
-template <class _Tp, class _Compare, class _Allocator>
-pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
-__tree<_Tp, _Compare, _Allocator>::__insert_unique(const value_type& __v)
-{
-    __node_base_pointer __parent;
-    __node_base_pointer& __child = __find_equal(__parent, __v);
-    __node_pointer __r = static_cast<__node_pointer>(__child);
-    bool __inserted = false;
-    if (__child == nullptr)
-    {
-        __node_holder __h = __construct_node(__v);
-        __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
-        __r = __h.release();
-        __inserted = true;
-    }
-    return pair<iterator, bool>(iterator(__r), __inserted);
-}
+#endif  // _LIBCPP_CXX03_LANG
 
+#ifdef _LIBCPP_CXX03_LANG
 template <class _Tp, class _Compare, class _Allocator>
 typename __tree<_Tp, _Compare, _Allocator>::iterator
-__tree<_Tp, _Compare, _Allocator>::__insert_unique(const_iterator __p, const value_type& __v)
+__tree<_Tp, _Compare, _Allocator>::__insert_multi(const __container_value_type& __v)
 {
-    __node_base_pointer __parent;
-    __node_base_pointer& __child = __find_equal(__p, __parent, __v);
-    __node_pointer __r = static_cast<__node_pointer>(__child);
-    if (__child == nullptr)
-    {
-        __node_holder __h = __construct_node(__v);
-        __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
-        __r = __h.release();
-    }
-    return iterator(__r);
-}
-
-template <class _Tp, class _Compare, class _Allocator>
-typename __tree<_Tp, _Compare, _Allocator>::iterator
-__tree<_Tp, _Compare, _Allocator>::__insert_multi(const value_type& __v)
-{
-    __node_base_pointer __parent;
-    __node_base_pointer& __child = __find_leaf_high(__parent, __v);
+    __parent_pointer __parent;
+    __node_base_pointer& __child = __find_leaf_high(__parent, _NodeTypes::__get_key(__v));
     __node_holder __h = __construct_node(__v);
     __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
     return iterator(__h.release());
@@ -1890,20 +2240,21 @@ __tree<_Tp, _Compare, _Allocator>::__insert_multi(const value_type& __v)
 
 template <class _Tp, class _Compare, class _Allocator>
 typename __tree<_Tp, _Compare, _Allocator>::iterator
-__tree<_Tp, _Compare, _Allocator>::__insert_multi(const_iterator __p, const value_type& __v)
+__tree<_Tp, _Compare, _Allocator>::__insert_multi(const_iterator __p, const __container_value_type& __v)
 {
-    __node_base_pointer __parent;
-    __node_base_pointer& __child = __find_leaf(__p, __parent, __v);
+    __parent_pointer __parent;
+    __node_base_pointer& __child = __find_leaf(__p, __parent, _NodeTypes::__get_key(__v));
     __node_holder __h = __construct_node(__v);
     __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
     return iterator(__h.release());
 }
+#endif
 
 template <class _Tp, class _Compare, class _Allocator>
 pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
 __tree<_Tp, _Compare, _Allocator>::__node_insert_unique(__node_pointer __nd)
 {
-    __node_base_pointer __parent;
+    __parent_pointer __parent;
     __node_base_pointer& __child = __find_equal(__parent, __nd->__value_);
     __node_pointer __r = static_cast<__node_pointer>(__child);
     bool __inserted = false;
@@ -1921,7 +2272,8 @@ typename __tree<_Tp, _Compare, _Allocator>::iterator
 __tree<_Tp, _Compare, _Allocator>::__node_insert_unique(const_iterator __p,
                                                         __node_pointer __nd)
 {
-    __node_base_pointer __parent;
+    __parent_pointer __parent;
+    __node_base_pointer __dummy;
     __node_base_pointer& __child = __find_equal(__p, __parent, __nd->__value_);
     __node_pointer __r = static_cast<__node_pointer>(__child);
     if (__child == nullptr)
@@ -1936,8 +2288,8 @@ template <class _Tp, class _Compare, class _Allocator>
 typename __tree<_Tp, _Compare, _Allocator>::iterator
 __tree<_Tp, _Compare, _Allocator>::__node_insert_multi(__node_pointer __nd)
 {
-    __node_base_pointer __parent;
-    __node_base_pointer& __child = __find_leaf_high(__parent, __nd->__value_);
+    __parent_pointer __parent;
+    __node_base_pointer& __child = __find_leaf_high(__parent, _NodeTypes::__get_key(__nd->__value_));
     __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__nd));
     return iterator(__nd);
 }
@@ -1947,8 +2299,8 @@ typename __tree<_Tp, _Compare, _Allocator>::iterator
 __tree<_Tp, _Compare, _Allocator>::__node_insert_multi(const_iterator __p,
                                                        __node_pointer __nd)
 {
-    __node_base_pointer __parent;
-    __node_base_pointer& __child = __find_leaf(__p, __parent, __nd->__value_);
+    __parent_pointer __parent;
+    __node_base_pointer& __child = __find_leaf(__p, __parent, _NodeTypes::__get_key(__nd->__value_));
     __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__nd));
     return iterator(__nd);
 }
@@ -1957,16 +2309,17 @@ template <class _Tp, class _Compare, class _Allocator>
 typename __tree<_Tp, _Compare, _Allocator>::iterator
 __tree<_Tp, _Compare, _Allocator>::erase(const_iterator __p)
 {
-    __node_pointer __np = __p.__ptr_;
-    iterator __r(__np);
+    __node_pointer __np = __p.__get_np();
+    iterator __r(__p.__ptr_);
     ++__r;
-    if (__begin_node() == __np)
+    if (__begin_node() == __p.__ptr_)
         __begin_node() = __r.__ptr_;
     --size();
     __node_allocator& __na = __node_alloc();
     __tree_remove(__end_node()->__left_,
                   static_cast<__node_base_pointer>(__np));
-    __node_traits::destroy(__na, const_cast<value_type*>(_VSTD::addressof(*__p)));
+    __node_traits::destroy(__na, _NodeTypes::__get_ptr(
+        const_cast<__node_value_type&>(*__p)));
     __node_traits::deallocate(__na, __np, 1);
     return __r;
 }
@@ -2031,17 +2384,15 @@ template <class _Key>
 typename __tree<_Tp, _Compare, _Allocator>::size_type
 __tree<_Tp, _Compare, _Allocator>::__count_unique(const _Key& __k) const
 {
-    __node_const_pointer __result = __end_node();
-    __node_const_pointer __rt = __root();
+    __node_pointer __rt = __root();
     while (__rt != nullptr)
     {
         if (value_comp()(__k, __rt->__value_))
         {
-            __result = __rt;
-            __rt = static_cast<__node_const_pointer>(__rt->__left_);
+            __rt = static_cast<__node_pointer>(__rt->__left_);
         }
         else if (value_comp()(__rt->__value_, __k))
-            __rt = static_cast<__node_const_pointer>(__rt->__right_);
+            __rt = static_cast<__node_pointer>(__rt->__right_);
         else
             return 1;
     }
@@ -2053,21 +2404,21 @@ template <class _Key>
 typename __tree<_Tp, _Compare, _Allocator>::size_type
 __tree<_Tp, _Compare, _Allocator>::__count_multi(const _Key& __k) const
 {
-    __node_const_pointer __result = __end_node();
-    __node_const_pointer __rt = __root();
+    __iter_pointer __result = __end_node();
+    __node_pointer __rt = __root();
     while (__rt != nullptr)
     {
         if (value_comp()(__k, __rt->__value_))
         {
-            __result = __rt;
-            __rt = static_cast<__node_const_pointer>(__rt->__left_);
+            __result = static_cast<__iter_pointer>(__rt);
+            __rt = static_cast<__node_pointer>(__rt->__left_);
         }
         else if (value_comp()(__rt->__value_, __k))
-            __rt = static_cast<__node_const_pointer>(__rt->__right_);
+            __rt = static_cast<__node_pointer>(__rt->__right_);
         else
             return _VSTD::distance(
-                __lower_bound(__k, static_cast<__node_const_pointer>(__rt->__left_), __rt),
-                __upper_bound(__k, static_cast<__node_const_pointer>(__rt->__right_), __result)
+                __lower_bound(__k, static_cast<__node_pointer>(__rt->__left_), static_cast<__iter_pointer>(__rt)),
+                __upper_bound(__k, static_cast<__node_pointer>(__rt->__right_), __result)
             );
     }
     return 0;
@@ -2078,13 +2429,13 @@ template <class _Key>
 typename __tree<_Tp, _Compare, _Allocator>::iterator
 __tree<_Tp, _Compare, _Allocator>::__lower_bound(const _Key& __v,
                                                  __node_pointer __root,
-                                                 __node_pointer __result)
+                                                 __iter_pointer __result)
 {
     while (__root != nullptr)
     {
         if (!value_comp()(__root->__value_, __v))
         {
-            __result = __root;
+            __result = static_cast<__iter_pointer>(__root);
             __root = static_cast<__node_pointer>(__root->__left_);
         }
         else
@@ -2097,18 +2448,18 @@ template <class _Tp, class _Compare, class _Allocator>
 template <class _Key>
 typename __tree<_Tp, _Compare, _Allocator>::const_iterator
 __tree<_Tp, _Compare, _Allocator>::__lower_bound(const _Key& __v,
-                                                 __node_const_pointer __root,
-                                                 __node_const_pointer __result) const
+                                                 __node_pointer __root,
+                                                 __iter_pointer __result) const
 {
     while (__root != nullptr)
     {
         if (!value_comp()(__root->__value_, __v))
         {
-            __result = __root;
-            __root = static_cast<__node_const_pointer>(__root->__left_);
+            __result = static_cast<__iter_pointer>(__root);
+            __root = static_cast<__node_pointer>(__root->__left_);
         }
         else
-            __root = static_cast<__node_const_pointer>(__root->__right_);
+            __root = static_cast<__node_pointer>(__root->__right_);
     }
     return const_iterator(__result);
 }
@@ -2118,13 +2469,13 @@ template <class _Key>
 typename __tree<_Tp, _Compare, _Allocator>::iterator
 __tree<_Tp, _Compare, _Allocator>::__upper_bound(const _Key& __v,
                                                  __node_pointer __root,
-                                                 __node_pointer __result)
+                                                 __iter_pointer __result)
 {
     while (__root != nullptr)
     {
         if (value_comp()(__v, __root->__value_))
         {
-            __result = __root;
+            __result = static_cast<__iter_pointer>(__root);
             __root = static_cast<__node_pointer>(__root->__left_);
         }
         else
@@ -2137,18 +2488,18 @@ template <class _Tp, class _Compare, class _Allocator>
 template <class _Key>
 typename __tree<_Tp, _Compare, _Allocator>::const_iterator
 __tree<_Tp, _Compare, _Allocator>::__upper_bound(const _Key& __v,
-                                                 __node_const_pointer __root,
-                                                 __node_const_pointer __result) const
+                                                 __node_pointer __root,
+                                                 __iter_pointer __result) const
 {
     while (__root != nullptr)
     {
         if (value_comp()(__v, __root->__value_))
         {
-            __result = __root;
-            __root = static_cast<__node_const_pointer>(__root->__left_);
+            __result = static_cast<__iter_pointer>(__root);
+            __root = static_cast<__node_pointer>(__root->__left_);
         }
         else
-            __root = static_cast<__node_const_pointer>(__root->__right_);
+            __root = static_cast<__node_pointer>(__root->__right_);
     }
     return const_iterator(__result);
 }
@@ -2160,13 +2511,13 @@ pair<typename __tree<_Tp, _Compare, _Allocator>::iterator,
 __tree<_Tp, _Compare, _Allocator>::__equal_range_unique(const _Key& __k)
 {
     typedef pair<iterator, iterator> _Pp;
-    __node_pointer __result = __end_node();
+    __iter_pointer __result = __end_node();
     __node_pointer __rt = __root();
     while (__rt != nullptr)
     {
         if (value_comp()(__k, __rt->__value_))
         {
-            __result = __rt;
+            __result = static_cast<__iter_pointer>(__rt);
             __rt = static_cast<__node_pointer>(__rt->__left_);
         }
         else if (value_comp()(__rt->__value_, __k))
@@ -2175,7 +2526,7 @@ __tree<_Tp, _Compare, _Allocator>::__equal_range_unique(const _Key& __k)
             return _Pp(iterator(__rt),
                       iterator(
                           __rt->__right_ != nullptr ?
-                              static_cast<__node_pointer>(__tree_min(__rt->__right_))
+                              static_cast<__iter_pointer>(__tree_min(__rt->__right_))
                             : __result));
     }
     return _Pp(iterator(__result), iterator(__result));
@@ -2188,22 +2539,22 @@ pair<typename __tree<_Tp, _Compare, _Allocator>::const_iterator,
 __tree<_Tp, _Compare, _Allocator>::__equal_range_unique(const _Key& __k) const
 {
     typedef pair<const_iterator, const_iterator> _Pp;
-    __node_const_pointer __result = __end_node();
-    __node_const_pointer __rt = __root();
+    __iter_pointer __result = __end_node();
+    __node_pointer __rt = __root();
     while (__rt != nullptr)
     {
         if (value_comp()(__k, __rt->__value_))
         {
-            __result = __rt;
-            __rt = static_cast<__node_const_pointer>(__rt->__left_);
+            __result = static_cast<__iter_pointer>(__rt);
+            __rt = static_cast<__node_pointer>(__rt->__left_);
         }
         else if (value_comp()(__rt->__value_, __k))
-            __rt = static_cast<__node_const_pointer>(__rt->__right_);
+            __rt = static_cast<__node_pointer>(__rt->__right_);
         else
             return _Pp(const_iterator(__rt),
                       const_iterator(
                           __rt->__right_ != nullptr ?
-                              static_cast<__node_const_pointer>(__tree_min(__rt->__right_))
+                              static_cast<__iter_pointer>(__tree_min(__rt->__right_))
                             : __result));
     }
     return _Pp(const_iterator(__result), const_iterator(__result));
@@ -2216,19 +2567,19 @@ pair<typename __tree<_Tp, _Compare, _Allocator>::iterator,
 __tree<_Tp, _Compare, _Allocator>::__equal_range_multi(const _Key& __k)
 {
     typedef pair<iterator, iterator> _Pp;
-    __node_pointer __result = __end_node();
+    __iter_pointer __result = __end_node();
     __node_pointer __rt = __root();
     while (__rt != nullptr)
     {
         if (value_comp()(__k, __rt->__value_))
         {
-            __result = __rt;
+            __result = static_cast<__iter_pointer>(__rt);
             __rt = static_cast<__node_pointer>(__rt->__left_);
         }
         else if (value_comp()(__rt->__value_, __k))
             __rt = static_cast<__node_pointer>(__rt->__right_);
         else
-            return _Pp(__lower_bound(__k, static_cast<__node_pointer>(__rt->__left_), __rt),
+            return _Pp(__lower_bound(__k, static_cast<__node_pointer>(__rt->__left_), static_cast<__iter_pointer>(__rt)),
                       __upper_bound(__k, static_cast<__node_pointer>(__rt->__right_), __result));
     }
     return _Pp(iterator(__result), iterator(__result));
@@ -2241,20 +2592,20 @@ pair<typename __tree<_Tp, _Compare, _Allocator>::const_iterator,
 __tree<_Tp, _Compare, _Allocator>::__equal_range_multi(const _Key& __k) const
 {
     typedef pair<const_iterator, const_iterator> _Pp;
-    __node_const_pointer __result = __end_node();
-    __node_const_pointer __rt = __root();
+    __iter_pointer __result = __end_node();
+    __node_pointer __rt = __root();
     while (__rt != nullptr)
     {
         if (value_comp()(__k, __rt->__value_))
         {
-            __result = __rt;
-            __rt = static_cast<__node_const_pointer>(__rt->__left_);
+            __result = static_cast<__iter_pointer>(__rt);
+            __rt = static_cast<__node_pointer>(__rt->__left_);
         }
         else if (value_comp()(__rt->__value_, __k))
-            __rt = static_cast<__node_const_pointer>(__rt->__right_);
+            __rt = static_cast<__node_pointer>(__rt->__right_);
         else
-            return _Pp(__lower_bound(__k, static_cast<__node_const_pointer>(__rt->__left_), __rt),
-                      __upper_bound(__k, static_cast<__node_const_pointer>(__rt->__right_), __result));
+            return _Pp(__lower_bound(__k, static_cast<__node_pointer>(__rt->__left_), static_cast<__iter_pointer>(__rt)),
+                      __upper_bound(__k, static_cast<__node_pointer>(__rt->__right_), __result));
     }
     return _Pp(const_iterator(__result), const_iterator(__result));
 }
@@ -2263,13 +2614,13 @@ template <class _Tp, class _Compare, class _Allocator>
 typename __tree<_Tp, _Compare, _Allocator>::__node_holder
 __tree<_Tp, _Compare, _Allocator>::remove(const_iterator __p) _NOEXCEPT
 {
-    __node_pointer __np = __p.__ptr_;
-    if (__begin_node() == __np)
+    __node_pointer __np = __p.__get_np();
+    if (__begin_node() == __p.__ptr_)
     {
         if (__np->__right_ != nullptr)
-            __begin_node() = static_cast<__node_pointer>(__np->__right_);
+            __begin_node() = static_cast<__iter_pointer>(__np->__right_);
         else
-            __begin_node() = static_cast<__node_pointer>(__np->__parent_);
+            __begin_node() = static_cast<__iter_pointer>(__np->__parent_);
     }
     --size();
     __tree_remove(__end_node()->__left_,
diff --git a/include/__tuple b/include/__tuple
index 8c31759774de..cc9fbbebc096 100644
--- a/include/__tuple
+++ b/include/__tuple
@@ -68,6 +68,80 @@ template <class _Tp> struct __tuple_like<const volatile _Tp> : public __tuple_li
 // tuple specializations
 
 #if !defined(_LIBCPP_HAS_NO_VARIADICS)
+
+template <size_t...> struct __tuple_indices {};
+
+template <class _IdxType, _IdxType... _Values>
+struct __integer_sequence {
+  template <template <class _OIdxType, _OIdxType...> class _ToIndexSeq, class _ToIndexType>
+  using __convert = _ToIndexSeq<_ToIndexType, _Values...>;
+
+  template <size_t _Sp>
+  using __to_tuple_indices = __tuple_indices<(_Values + _Sp)...>;
+};
+
+#if !__has_builtin(__make_integer_seq) || defined(_LIBCPP_TESTING_FALLBACK_MAKE_INTEGER_SEQUENCE)
+namespace __detail {
+
+template<typename _Tp, size_t ..._Extra> struct __repeat;
+template<typename _Tp, _Tp ..._Np, size_t ..._Extra> struct __repeat<__integer_sequence<_Tp, _Np...>, _Extra...> {
+  typedef __integer_sequence<_Tp,
+                           _Np...,
+                           sizeof...(_Np) + _Np...,
+                           2 * sizeof...(_Np) + _Np...,
+                           3 * sizeof...(_Np) + _Np...,
+                           4 * sizeof...(_Np) + _Np...,
+                           5 * sizeof...(_Np) + _Np...,
+                           6 * sizeof...(_Np) + _Np...,
+                           7 * sizeof...(_Np) + _Np...,
+                           _Extra...> type;
+};
+
+template<size_t _Np> struct __parity;
+template<size_t _Np> struct __make : __parity<_Np % 8>::template __pmake<_Np> {};
+
+template<> struct __make<0> { typedef __integer_sequence<size_t> type; };
+template<> struct __make<1> { typedef __integer_sequence<size_t, 0> type; };
+template<> struct __make<2> { typedef __integer_sequence<size_t, 0, 1> type; };
+template<> struct __make<3> { typedef __integer_sequence<size_t, 0, 1, 2> type; };
+template<> struct __make<4> { typedef __integer_sequence<size_t, 0, 1, 2, 3> type; };
+template<> struct __make<5> { typedef __integer_sequence<size_t, 0, 1, 2, 3, 4> type; };
+template<> struct __make<6> { typedef __integer_sequence<size_t, 0, 1, 2, 3, 4, 5> type; };
+template<> struct __make<7> { typedef __integer_sequence<size_t, 0, 1, 2, 3, 4, 5, 6> type; };
+
+template<> struct __parity<0> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type> {}; };
+template<> struct __parity<1> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 1> {}; };
+template<> struct __parity<2> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 2, _Np - 1> {}; };
+template<> struct __parity<3> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 3, _Np - 2, _Np - 1> {}; };
+template<> struct __parity<4> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
+template<> struct __parity<5> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
+template<> struct __parity<6> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 6, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
+template<> struct __parity<7> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 7, _Np - 6, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
+
+} // namespace detail
+
+#endif  // !__has_builtin(__make_integer_seq) || defined(_LIBCPP_TESTING_FALLBACK_MAKE_INTEGER_SEQUENCE)
+
+#if __has_builtin(__make_integer_seq)
+template <size_t _Ep, size_t _Sp>
+using __make_indices_imp =
+    typename __make_integer_seq<__integer_sequence, size_t, _Ep - _Sp>::template
+    __to_tuple_indices<_Sp>;
+#else
+template <size_t _Ep, size_t _Sp>
+using __make_indices_imp =
+    typename __detail::__make<_Ep - _Sp>::type::template __to_tuple_indices<_Sp>;
+
+#endif
+
+template <size_t _Ep, size_t _Sp = 0>
+struct __make_tuple_indices
+{
+    static_assert(_Sp <= _Ep, "__make_tuple_indices input error");
+    typedef __make_indices_imp<_Ep, _Sp> type;
+};
+
+
 template <class ..._Tp> class _LIBCPP_TYPE_VIS_ONLY tuple;
 
 template <class... _Tp> struct __tuple_like<tuple<_Tp...> > : true_type {};
@@ -95,8 +169,6 @@ get(const tuple<_Tp...>&&) _NOEXCEPT;
 
 // pair specializations
 
-template <class _T1, class _T2> struct _LIBCPP_TYPE_VIS_ONLY pair;
-
 template <class _T1, class _T2> struct __tuple_like<pair<_T1, _T2> > : true_type {};
 
 template <size_t _Ip, class _T1, class _T2>
@@ -151,58 +223,49 @@ get(const array<_Tp, _Size>&&) _NOEXCEPT;
 
 #if !defined(_LIBCPP_HAS_NO_VARIADICS)
 
-// __make_tuple_indices
 
-template <size_t...> struct __tuple_indices {};
+// __tuple_types
 
-template <size_t _Sp, class _IntTuple, size_t _Ep>
-struct __make_indices_imp;
+template <class ..._Tp> struct __tuple_types {};
 
-template <size_t _Sp, size_t ..._Indices, size_t _Ep>
-struct __make_indices_imp<_Sp, __tuple_indices<_Indices...>, _Ep>
-{
-    typedef typename __make_indices_imp<_Sp+1, __tuple_indices<_Indices..., _Sp>, _Ep>::type type;
-};
+#if !__has_builtin(__type_pack_element)
 
-template <size_t _Ep, size_t ..._Indices>
-struct __make_indices_imp<_Ep, __tuple_indices<_Indices...>, _Ep>
-{
-    typedef __tuple_indices<_Indices...> type;
-};
+namespace __indexer_detail {
 
-template <size_t _Ep, size_t _Sp = 0>
-struct __make_tuple_indices
-{
-    static_assert(_Sp <= _Ep, "__make_tuple_indices input error");
-    typedef typename __make_indices_imp<_Sp, __tuple_indices<>, _Ep>::type type;
-};
+template <size_t _Idx, class _Tp>
+struct __indexed { using type = _Tp; };
 
-// __tuple_types
+template <class _Types, class _Indexes> struct __indexer;
 
-template <class ..._Tp> struct __tuple_types {};
+template <class ..._Types, size_t ..._Idx>
+struct __indexer<__tuple_types<_Types...>, __tuple_indices<_Idx...>>
+    : __indexed<_Idx, _Types>...
+{};
 
-template <size_t _Ip>
-class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, __tuple_types<> >
-{
-public:
-    static_assert(_Ip == 0, "tuple_element index out of range");
-    static_assert(_Ip != 0, "tuple_element index out of range");
-};
+template <size_t _Idx, class _Tp>
+__indexed<_Idx, _Tp> __at_index(__indexed<_Idx, _Tp> const&);
 
-template <class _Hp, class ..._Tp>
-class _LIBCPP_TYPE_VIS_ONLY tuple_element<0, __tuple_types<_Hp, _Tp...> >
-{
-public:
-    typedef _Hp type;
-};
+} // namespace __indexer_detail
+
+template <size_t _Idx, class ..._Types>
+using __type_pack_element = typename decltype(
+    __indexer_detail::__at_index<_Idx>(
+        __indexer_detail::__indexer<
+            __tuple_types<_Types...>,
+            typename __make_tuple_indices<sizeof...(_Types)>::type
+        >{})
+  )::type;
+#endif
 
-template <size_t _Ip, class _Hp, class ..._Tp>
-class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, __tuple_types<_Hp, _Tp...> >
+template <size_t _Ip, class ..._Types>
+class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, __tuple_types<_Types...>>
 {
 public:
-    typedef typename tuple_element<_Ip-1, __tuple_types<_Tp...> >::type type;
+    static_assert(_Ip < sizeof...(_Types), "tuple_element index out of range");
+    typedef __type_pack_element<_Ip, _Types...> type;
 };
 
+
 template <class ..._Tp>
 class _LIBCPP_TYPE_VIS_ONLY tuple_size<__tuple_types<_Tp...> >
     : public integral_constant<size_t, sizeof...(_Tp)>
@@ -211,6 +274,46 @@ class _LIBCPP_TYPE_VIS_ONLY tuple_size<__tuple_types<_Tp...> >
 
 template <class... _Tp> struct __tuple_like<__tuple_types<_Tp...> > : true_type {};
 
+template <bool _ApplyLV, bool _ApplyConst, bool _ApplyVolatile>
+struct __apply_cv_mf;
+template <>
+struct __apply_cv_mf<false, false, false> {
+  template <class _Tp> using __apply = _Tp;
+};
+template <>
+struct __apply_cv_mf<false, true, false> {
+  template <class _Tp> using __apply = const _Tp;
+};
+template <>
+struct __apply_cv_mf<false, false, true> {
+  template <class _Tp> using __apply = volatile _Tp;
+};
+template <>
+struct __apply_cv_mf<false, true, true> {
+  template <class _Tp> using __apply = const volatile _Tp;
+};
+template <>
+struct __apply_cv_mf<true, false, false> {
+  template <class _Tp> using __apply = _Tp&;
+};
+template <>
+struct __apply_cv_mf<true, true, false> {
+  template <class _Tp> using __apply = const _Tp&;
+};
+template <>
+struct __apply_cv_mf<true, false, true> {
+  template <class _Tp> using __apply = volatile _Tp&;
+};
+template <>
+struct __apply_cv_mf<true, true, true> {
+  template <class _Tp> using __apply = const volatile _Tp&;
+};
+template <class _Tp, class _RawTp = typename remove_reference<_Tp>::type>
+using __apply_cv_t = __apply_cv_mf<
+    is_lvalue_reference<_Tp>::value,
+    is_const<_RawTp>::value,
+    is_volatile<_RawTp>::value>;
+
 // __make_tuple_types
 
 // __make_tuple_types<_Tuple<_Types...>, _Ep, _Sp>::type is a
@@ -218,58 +321,72 @@ template <class... _Tp> struct __tuple_like<__tuple_types<_Tp...> > : true_type
 // _Sp defaults to 0 and _Ep defaults to tuple_size<_Tuple>.  If _Tuple is a
 // lvalue_reference type, then __tuple_types<_Types&...> is the result.
 
-template <class _TupleTypes, class _Tp, size_t _Sp, size_t _Ep>
-struct __make_tuple_types_imp;
+template <class _TupleTypes, class _TupleIndices>
+struct __make_tuple_types_flat;
 
-template <class ..._Types, class _Tp, size_t _Sp, size_t _Ep>
-struct __make_tuple_types_imp<__tuple_types<_Types...>, _Tp, _Sp, _Ep>
-{
-    typedef typename remove_reference<_Tp>::type _Tpr;
-    typedef typename __make_tuple_types_imp<__tuple_types<_Types...,
-                                            typename conditional<is_lvalue_reference<_Tp>::value,
-                                                typename tuple_element<_Sp, _Tpr>::type&,
-                                                typename tuple_element<_Sp, _Tpr>::type>::type>,
-                                            _Tp, _Sp+1, _Ep>::type type;
+template <template <class...> class _Tuple, class ..._Types, size_t ..._Idx>
+struct __make_tuple_types_flat<_Tuple<_Types...>, __tuple_indices<_Idx...>> {
+  // Specialization for pair, tuple, and __tuple_types
+  template <class _Tp, class _ApplyFn = __apply_cv_t<_Tp>>
+  using __apply_quals = __tuple_types<
+      typename _ApplyFn::template __apply<__type_pack_element<_Idx, _Types...>>...
+    >;
 };
 
-template <class ..._Types, class _Tp, size_t _Ep>
-struct __make_tuple_types_imp<__tuple_types<_Types...>, _Tp, _Ep, _Ep>
-{
-    typedef __tuple_types<_Types...> type;
+template <class _Vt, size_t _Np, size_t ..._Idx>
+struct __make_tuple_types_flat<array<_Vt, _Np>, __tuple_indices<_Idx...>> {
+  template <size_t>
+  using __value_type = _Vt;
+  template <class _Tp, class _ApplyFn = __apply_cv_t<_Tp>>
+  using __apply_quals = __tuple_types<
+      typename _ApplyFn::template __apply<__value_type<_Idx>>...
+    >;
 };
 
-template <class _Tp, size_t _Ep = tuple_size<typename remove_reference<_Tp>::type>::value, size_t _Sp = 0>
+template <class _Tp, size_t _Ep = tuple_size<typename remove_reference<_Tp>::type>::value,
+          size_t _Sp = 0,
+          bool _SameSize = (_Ep == tuple_size<typename remove_reference<_Tp>::type>::value)>
 struct __make_tuple_types
 {
     static_assert(_Sp <= _Ep, "__make_tuple_types input error");
-    typedef typename __make_tuple_types_imp<__tuple_types<>, _Tp, _Sp, _Ep>::type type;
+    using _RawTp = typename remove_cv<typename remove_reference<_Tp>::type>::type;
+    using _Maker = __make_tuple_types_flat<_RawTp, typename __make_tuple_indices<_Ep, _Sp>::type>;
+    using type = typename _Maker::template __apply_quals<_Tp>;
 };
 
-// __tuple_convertible
-
-template <class, class>
-struct __tuple_convertible_imp : public false_type {};
-
-template <class _Tp0, class ..._Tp, class _Up0, class ..._Up>
-struct __tuple_convertible_imp<__tuple_types<_Tp0, _Tp...>, __tuple_types<_Up0, _Up...> >
-    : public integral_constant<bool,
-                               is_convertible<_Tp0, _Up0>::value &&
-                               __tuple_convertible_imp<__tuple_types<_Tp...>, __tuple_types<_Up...> >::value> {};
+template <class ..._Types, size_t _Ep>
+struct __make_tuple_types<tuple<_Types...>, _Ep, 0, true> {
+  typedef __tuple_types<_Types...> type;
+};
 
-template <>
-struct __tuple_convertible_imp<__tuple_types<>, __tuple_types<> >
-    : public true_type {};
+template <class ..._Types, size_t _Ep>
+struct __make_tuple_types<__tuple_types<_Types...>, _Ep, 0, true> {
+  typedef __tuple_types<_Types...> type;
+};
 
-template <bool, class, class>
-struct __tuple_convertible_apply : public false_type {};
+template <bool ..._Preds>
+struct __all_dummy;
+
+template <bool ..._Pred>
+using __all = is_same<__all_dummy<_Pred...>, __all_dummy<(_Pred, true)...>>;
+
+struct __tuple_sfinae_base {
+  template <template <class, class...> class _Trait,
+            class ..._LArgs, class ..._RArgs>
+  static auto __do_test(__tuple_types<_LArgs...>, __tuple_types<_RArgs...>)
+    -> __all<typename enable_if<_Trait<_LArgs, _RArgs>::value, bool>::type{true}...>;
+  template <template <class...> class>
+  static auto __do_test(...) -> false_type;
+
+  template <class _FromArgs, class _ToArgs>
+  using __constructible = decltype(__do_test<is_constructible>(_ToArgs{}, _FromArgs{}));
+  template <class _FromArgs, class _ToArgs>
+  using __convertible = decltype(__do_test<is_convertible>(_FromArgs{}, _ToArgs{}));
+  template <class _FromArgs, class _ToArgs>
+  using __assignable = decltype(__do_test<is_assignable>(_ToArgs{}, _FromArgs{}));
+};
 
-template <class _Tp, class _Up>
-struct __tuple_convertible_apply<true, _Tp, _Up>
-  : public __tuple_convertible_imp<
-      typename __make_tuple_types<_Tp>::type
-    , typename __make_tuple_types<_Up>::type
-    >
-{};
+// __tuple_convertible
 
 template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value,
                                 bool = __tuple_like<_Up>::value>
@@ -278,36 +395,14 @@ struct __tuple_convertible
 
 template <class _Tp, class _Up>
 struct __tuple_convertible<_Tp, _Up, true, true>
-    : public __tuple_convertible_apply<tuple_size<typename remove_reference<_Tp>::type>::value ==
-                                     tuple_size<_Up>::value, _Tp, _Up>
-{};
-
-// __tuple_constructible
-
-template <class, class>
-struct __tuple_constructible_imp : public false_type {};
-
-template <class _Tp0, class ..._Tp, class _Up0, class ..._Up>
-struct __tuple_constructible_imp<__tuple_types<_Tp0, _Tp...>, __tuple_types<_Up0, _Up...> >
-    : public integral_constant<bool,
-                               is_constructible<_Up0, _Tp0>::value &&
-                               __tuple_constructible_imp<__tuple_types<_Tp...>, __tuple_types<_Up...> >::value> {};
-
-template <>
-struct __tuple_constructible_imp<__tuple_types<>, __tuple_types<> >
-    : public true_type {};
-
-template <bool _SameSize, class, class>
-struct __tuple_constructible_apply : public false_type {};
-
-template <class _Tp, class _Up>
-struct __tuple_constructible_apply<true, _Tp, _Up>
-  : public __tuple_constructible_imp<
+    : public __tuple_sfinae_base::__convertible<
       typename __make_tuple_types<_Tp>::type
     , typename __make_tuple_types<_Up>::type
     >
 {};
 
+// __tuple_constructible
+
 template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value,
                                 bool = __tuple_like<_Up>::value>
 struct __tuple_constructible
@@ -315,36 +410,14 @@ struct __tuple_constructible
 
 template <class _Tp, class _Up>
 struct __tuple_constructible<_Tp, _Up, true, true>
-    : public __tuple_constructible_apply<tuple_size<typename remove_reference<_Tp>::type>::value ==
-                                     tuple_size<_Up>::value, _Tp, _Up>
-{};
-
-// __tuple_assignable
-
-template <class, class>
-struct __tuple_assignable_imp : public false_type {};
-
-template <class _Tp0, class ..._Tp, class _Up0, class ..._Up>
-struct __tuple_assignable_imp<__tuple_types<_Tp0, _Tp...>, __tuple_types<_Up0, _Up...> >
-    : public integral_constant<bool,
-                               is_assignable<_Up0&, _Tp0>::value &&
-                               __tuple_assignable_imp<__tuple_types<_Tp...>, __tuple_types<_Up...> >::value> {};
-
-template <>
-struct __tuple_assignable_imp<__tuple_types<>, __tuple_types<> >
-    : public true_type {};
-
-template <bool, class, class>
-struct __tuple_assignable_apply : public false_type {};
-
-template <class _Tp, class _Up>
-struct __tuple_assignable_apply<true, _Tp, _Up>
-  : __tuple_assignable_imp<
+    : public __tuple_sfinae_base::__constructible<
       typename __make_tuple_types<_Tp>::type
     , typename __make_tuple_types<_Up>::type
     >
 {};
 
+// __tuple_assignable
+
 template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value,
                                 bool = __tuple_like<_Up>::value>
 struct __tuple_assignable
@@ -352,8 +425,10 @@ struct __tuple_assignable
 
 template <class _Tp, class _Up>
 struct __tuple_assignable<_Tp, _Up, true, true>
-    : public __tuple_assignable_apply<tuple_size<typename remove_reference<_Tp>::type>::value ==
-                                    tuple_size<_Up>::value, _Tp, _Up>
+    : public __tuple_sfinae_base::__assignable<
+      typename __make_tuple_types<_Tp>::type
+    , typename __make_tuple_types<_Up&>::type
+    >
 {};
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
diff --git a/include/__undef___deallocate b/include/__undef___deallocate
index 2b4ad99dad38..52f4d9987e21 100644
--- a/include/__undef___deallocate
+++ b/include/__undef___deallocate
@@ -9,10 +9,12 @@
 //===----------------------------------------------------------------------===//
 
 #ifdef __deallocate
+#if !defined(_LIBCPP_DISABLE_MACRO_CONFLICT_WARNINGS)
 #if defined(_MSC_VER) && !defined(__clang__)
 _LIBCPP_WARNING("macro __deallocate is incompatible with C++.  #undefining __deallocate")
 #else
 #warning: macro __deallocate is incompatible with C++.  #undefining __deallocate
 #endif
+#endif
 #undef __deallocate
 #endif
diff --git a/include/__undef_min_max b/include/__undef_min_max
index 5df9412c64fd..d3c31388cead 100644
--- a/include/__undef_min_max
+++ b/include/__undef_min_max
@@ -9,21 +9,25 @@
 //===----------------------------------------------------------------------===//
 
 #ifdef min
+#if !defined(_LIBCPP_DISABLE_MACRO_CONFLICT_WARNINGS)
 #if defined(_MSC_VER) && ! defined(__clang__)
 _LIBCPP_WARNING("macro min is incompatible with C++.  Try #define NOMINMAX "
                 "before any Windows header. #undefing min")
 #else
 #warning: macro min is incompatible with C++.  #undefing min
 #endif
+#endif
 #undef min
 #endif
 
 #ifdef max
+#if !defined(_LIBCPP_DISABLE_MACRO_CONFLICT_WARNINGS)
 #if defined(_MSC_VER) && ! defined(__clang__)
 _LIBCPP_WARNING("macro max is incompatible with C++.  Try #define NOMINMAX "
                 "before any Windows header. #undefing max")
 #else
 #warning: macro max is incompatible with C++.  #undefing max
 #endif
+#endif
 #undef max
 #endif
diff --git a/include/algorithm b/include/algorithm
index 71e5df37dfeb..7a6db7abd26d 100644
--- a/include/algorithm
+++ b/include/algorithm
@@ -543,6 +543,12 @@ template<class T, class Compare>
     T
     min(initializer_list<T> t, Compare comp);  // constexpr in C++14
 
+template<class T>
+    constexpr const T& clamp( const T& v, const T& lo, const T& hi );               // C++17
+
+template<class T, class Compare>
+    constexpr const T& clamp( const T& v, const T& lo, const T& hi, Compare comp ); // C++17
+
 template <class ForwardIterator>
     ForwardIterator
     max_element(ForwardIterator first, ForwardIterator last);  // constexpr in C++14
@@ -624,7 +630,7 @@ template <class BidirectionalIterator, class Compare>
 #include <initializer_list>
 #include <type_traits>
 #include <cstring>
-#include <utility>
+#include <utility> // needed to provide swap_ranges.
 #include <memory>
 #include <iterator>
 #include <cstddef>
@@ -1415,20 +1421,20 @@ is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
 // search
 
 template <class _BinaryPredicate, class _ForwardIterator1, class _ForwardIterator2>
-_ForwardIterator1
+pair<_ForwardIterator1, _ForwardIterator1>
 __search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
          _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred,
          forward_iterator_tag, forward_iterator_tag)
 {
     if (__first2 == __last2)
-        return __first1;  // Everything matches an empty sequence
+        return make_pair(__first1, __first1);  // Everything matches an empty sequence
     while (true)
     {
         // Find first element in sequence 1 that matchs *__first2, with a mininum of loop checks
         while (true)
         {
             if (__first1 == __last1)  // return __last1 if no element matches *__first2
-                return __last1;
+                return make_pair(__last1, __last1);
             if (__pred(*__first1, *__first2))
                 break;
             ++__first1;
@@ -1439,9 +1445,9 @@ __search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
         while (true)
         {
             if (++__m2 == __last2)  // If pattern exhausted, __first1 is the answer (works for 1 element pattern)
-                return __first1;
+                return make_pair(__first1, __m1);
             if (++__m1 == __last1)  // Otherwise if source exhaused, pattern not found
-                return __last1;
+                return make_pair(__last1, __last1);
             if (!__pred(*__m1, *__m2))  // if there is a mismatch, restart with a new __first1
             {
                 ++__first1;
@@ -1452,20 +1458,21 @@ __search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
 }
 
 template <class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2>
-_LIBCPP_CONSTEXPR_AFTER_CXX11 _RandomAccessIterator1
+_LIBCPP_CONSTEXPR_AFTER_CXX11 
+pair<_RandomAccessIterator1, _RandomAccessIterator1>
 __search(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
-           _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __pred,
+         _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __pred,
            random_access_iterator_tag, random_access_iterator_tag)
 {
-    typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type _D1;
-    typedef typename std::iterator_traits<_RandomAccessIterator2>::difference_type _D2;
+    typedef typename iterator_traits<_RandomAccessIterator1>::difference_type _D1;
+    typedef typename iterator_traits<_RandomAccessIterator2>::difference_type _D2;
     // Take advantage of knowing source and pattern lengths.  Stop short when source is smaller than pattern
-    _D2 __len2 = __last2 - __first2;
+    const _D2 __len2 = __last2 - __first2;
     if (__len2 == 0)
-        return __first1;
-    _D1 __len1 = __last1 - __first1;
+        return make_pair(__first1, __first1);
+    const _D1 __len1 = __last1 - __first1;
     if (__len1 < __len2)
-        return __last1;
+        return make_pair(__last1, __last1);
     const _RandomAccessIterator1 __s = __last1 - (__len2 - 1);  // Start of pattern match can't go beyond here
     while (true)
     {
@@ -1473,7 +1480,7 @@ __search(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
         while (true)
         {
             if (__first1 == __s)
-                return __last1;
+                return make_pair(__last1, __last1);
             if (__pred(*__first1, *__first2))
                 break;
             ++__first1;
@@ -1505,7 +1512,7 @@ __search(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
             if (__pred(*__first1, *__first2))
                 break;
         case 0:
-            return __last1;
+            return make_pair(__last1, __last1);
         }
     __phase2:
 #endif  // !_LIBCPP_UNROLL_LOOPS
@@ -1515,7 +1522,7 @@ __search(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
          while (true)
          {
              if (++__m2 == __last2)
-                 return __first1;
+                 return make_pair(__first1, __first1 + __len2);
              ++__m1;          // no need to check range on __m1 because __s guarantees we have enough source
              if (!__pred(*__m1, *__m2))
              {
@@ -1555,7 +1562,7 @@ __search(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
             if (!__pred(*__m1, *__m2))
                 break;
         case 0:
-            return __first1;
+            return make_pair(__first1, __first1 + __len2);
         }
     __continue:
         ++__first1;
@@ -1571,8 +1578,9 @@ search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
 {
     return _VSTD::__search<typename add_lvalue_reference<_BinaryPredicate>::type>
                          (__first1, __last1, __first2, __last2, __pred,
-                          typename std::iterator_traits<_ForwardIterator1>::iterator_category(),
-                          typename std::iterator_traits<_ForwardIterator2>::iterator_category());
+                          typename iterator_traits<_ForwardIterator1>::iterator_category(),
+                          typename iterator_traits<_ForwardIterator2>::iterator_category())
+            .first;
 }
 
 template <class _ForwardIterator1, class _ForwardIterator2>
@@ -1581,8 +1589,8 @@ _ForwardIterator1
 search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
        _ForwardIterator2 __first2, _ForwardIterator2 __last2)
 {
-    typedef typename std::iterator_traits<_ForwardIterator1>::value_type __v1;
-    typedef typename std::iterator_traits<_ForwardIterator2>::value_type __v2;
+    typedef typename iterator_traits<_ForwardIterator1>::value_type __v1;
+    typedef typename iterator_traits<_ForwardIterator2>::value_type __v2;
     return _VSTD::search(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>());
 }
 
@@ -2657,6 +2665,27 @@ max(initializer_list<_Tp> __t)
 
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
+#if _LIBCPP_STD_VER > 14
+// clamp
+template<class _Tp, class _Compare>
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
+const _Tp&
+clamp(const _Tp& __v, const _Tp& __lo, const _Tp& __hi, _Compare __comp)
+{
+    _LIBCPP_ASSERT(!__comp(__hi, __lo), "Bad bounds passed to std::clamp");
+    return __comp(__v, __lo) ? __lo : __comp(__hi, __v) ? __hi : __v;
+
+}
+
+template<class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
+const _Tp&
+clamp(const _Tp& __v, const _Tp& __lo, const _Tp& __hi)
+{
+    return _VSTD::clamp(__v, __lo, __hi, __less<_Tp>());
+}
+#endif
+
 // minmax_element
 
 template <class _ForwardIterator, class _Compare>
@@ -5725,34 +5754,6 @@ prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last)
                                   __less<typename iterator_traits<_BidirectionalIterator>::value_type>());
 }
 
-template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    is_integral<_Tp>::value,
-    _Tp
->::type
-__rotate_left(_Tp __t, _Tp __n = 1)
-{
-    const unsigned __bits = static_cast<unsigned>(sizeof(_Tp) * __CHAR_BIT__ - 1);
-    __n &= __bits;
-    return static_cast<_Tp>((__t << __n) | (static_cast<typename make_unsigned<_Tp>::type>(__t) >> (__bits - __n)));
-}
-
-template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    is_integral<_Tp>::value,
-    _Tp
->::type
-__rotate_right(_Tp __t, _Tp __n = 1)
-{
-    const unsigned __bits = static_cast<unsigned>(sizeof(_Tp) * __CHAR_BIT__ - 1);
-    __n &= __bits;
-    return static_cast<_Tp>((__t << (__bits - __n)) | (static_cast<typename make_unsigned<_Tp>::type>(__t) >> __n));
-}
-
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_ALGORITHM
diff --git a/include/array b/include/array
index 8866eaf6b463..719286d52ea3 100644
--- a/include/array
+++ b/include/array
@@ -34,7 +34,7 @@ struct array
 
     // No explicit construct/copy/destroy for aggregate type
     void fill(const T& u);
-    void swap(array& a) noexcept(noexcept(swap(declval<T&>(), declval<T&>())));
+    void swap(array& a) noexcept(is_nothrow_swappable_v<T>);
 
     // iterators:
     iterator begin() noexcept;
@@ -141,8 +141,15 @@ struct _LIBCPP_TYPE_VIS_ONLY array
     _LIBCPP_INLINE_VISIBILITY void fill(const value_type& __u)
         {_VSTD::fill_n(__elems_, _Size, __u);}
     _LIBCPP_INLINE_VISIBILITY
-    void swap(array& __a) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
-        {_VSTD::swap_ranges(__elems_, __elems_ + _Size, __a.__elems_);}
+    void swap(array& __a) _NOEXCEPT_(_Size == 0 || __is_nothrow_swappable<_Tp>::value)
+        { __swap_dispatch((std::integral_constant<bool, _Size == 0>()), __a); }
+
+    _LIBCPP_INLINE_VISIBILITY
+    void __swap_dispatch(std::true_type, array&) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    void __swap_dispatch(std::false_type, array& __a)
+        { _VSTD::swap_ranges(__elems_, __elems_ + _Size, __a.__elems_);}
 
     // iterators:
     _LIBCPP_INLINE_VISIBILITY
@@ -276,11 +283,12 @@ template <class _Tp, size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
+    _Size == 0 ||
     __is_swappable<_Tp>::value,
     void
 >::type
-swap(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
-                                  _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
+swap(array<_Tp, _Size>& __x, array<_Tp, _Size>& __y)
+                                  _NOEXCEPT_(noexcept(__x.swap(__y)))
 {
     __x.swap(__y);
 }
diff --git a/include/atomic b/include/atomic
index abec2a0b565a..11f2152e5bc6 100644
--- a/include/atomic
+++ b/include/atomic
@@ -17,6 +17,10 @@
 namespace std
 {
 
+// feature test macro
+
+#define __cpp_lib_atomic_is_always_lock_free // as specified by SG10
+
 // order and consistency
 
 typedef enum memory_order
@@ -89,6 +93,7 @@ void
 template <class T>
 struct atomic
 {
+    static constexpr bool is_always_lock_free;
     bool is_lock_free() const volatile noexcept;
     bool is_lock_free() const noexcept;
     void store(T desr, memory_order m = memory_order_seq_cst) volatile noexcept;
@@ -127,6 +132,7 @@ struct atomic
 template <>
 struct atomic<integral>
 {
+    static constexpr bool is_always_lock_free;
     bool is_lock_free() const volatile noexcept;
     bool is_lock_free() const noexcept;
     void store(integral desr, memory_order m = memory_order_seq_cst) volatile noexcept;
@@ -202,6 +208,7 @@ struct atomic<integral>
 template <class T>
 struct atomic<T*>
 {
+    static constexpr bool is_always_lock_free;
     bool is_lock_free() const volatile noexcept;
     bool is_lock_free() const noexcept;
     void store(T* desr, memory_order m = memory_order_seq_cst) volatile noexcept;
@@ -508,6 +515,15 @@ typedef atomic<uint_fast32_t> atomic_uint_fast32_t;
 typedef atomic<int_fast64_t>  atomic_int_fast64_t;
 typedef atomic<uint_fast64_t> atomic_uint_fast64_t;
 
+typedef atomic<int8_t>   atomic_int8_t;
+typedef atomic<uint8_t>  atomic_uint8_t;
+typedef atomic<int16_t>  atomic_int16_t;
+typedef atomic<uint16_t> atomic_uint16_t;
+typedef atomic<int32_t>  atomic_int32_t;
+typedef atomic<uint32_t> atomic_uint32_t;
+typedef atomic<int64_t>  atomic_int64_t;
+typedef atomic<uint64_t> atomic_uint64_t;
+
 typedef atomic<intptr_t>  atomic_intptr_t;
 typedef atomic<uintptr_t> atomic_uintptr_t;
 typedef atomic<size_t>    atomic_size_t;
@@ -540,6 +556,11 @@ void atomic_signal_fence(memory_order m) noexcept;
 #error <atomic> is not implemented
 #endif
 
+#if _LIBCPP_STD_VER > 14
+// FIXME: use the right feature test macro value as chose by SG10.
+# define __cpp_lib_atomic_is_always_lock_free 201603L
+#endif
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 typedef enum memory_order
@@ -825,6 +846,17 @@ kill_dependency(_Tp __y) _NOEXCEPT
     return __y;
 }
 
+#define ATOMIC_BOOL_LOCK_FREE      __GCC_ATOMIC_BOOL_LOCK_FREE
+#define ATOMIC_CHAR_LOCK_FREE      __GCC_ATOMIC_CHAR_LOCK_FREE
+#define ATOMIC_CHAR16_T_LOCK_FREE  __GCC_ATOMIC_CHAR16_T_LOCK_FREE
+#define ATOMIC_CHAR32_T_LOCK_FREE  __GCC_ATOMIC_CHAR32_T_LOCK_FREE
+#define ATOMIC_WCHAR_T_LOCK_FREE   __GCC_ATOMIC_WCHAR_T_LOCK_FREE
+#define ATOMIC_SHORT_LOCK_FREE     __GCC_ATOMIC_SHORT_LOCK_FREE
+#define ATOMIC_INT_LOCK_FREE       __GCC_ATOMIC_INT_LOCK_FREE
+#define ATOMIC_LONG_LOCK_FREE      __GCC_ATOMIC_LONG_LOCK_FREE
+#define ATOMIC_LLONG_LOCK_FREE     __GCC_ATOMIC_LLONG_LOCK_FREE
+#define ATOMIC_POINTER_LOCK_FREE   __GCC_ATOMIC_POINTER_LOCK_FREE
+
 // general atomic<T>
 
 template <class _Tp, bool = is_integral<_Tp>::value && !is_same<_Tp, bool>::value>
@@ -832,6 +864,10 @@ struct __atomic_base  // false
 {
     mutable _Atomic(_Tp) __a_;
 
+#if defined(__cpp_lib_atomic_is_always_lock_free)
+  static _LIBCPP_CONSTEXPR bool is_always_lock_free = __atomic_always_lock_free(sizeof(__a_), 0);
+#endif
+
     _LIBCPP_INLINE_VISIBILITY
     bool is_lock_free() const volatile _NOEXCEPT
     {
@@ -920,6 +956,11 @@ private:
 #endif  // _LIBCPP_HAS_NO_DELETED_FUNCTIONS
 };
 
+#if defined(__cpp_lib_atomic_is_always_lock_free)
+template <class _Tp, bool __b>
+_LIBCPP_CONSTEXPR bool __atomic_base<_Tp, __b>::is_always_lock_free;
+#endif
+
 // atomic<Integral>
 
 template <class _Tp>
@@ -1657,7 +1698,7 @@ typedef struct atomic_flag
 #endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
 
     _LIBCPP_INLINE_VISIBILITY
-    atomic_flag(bool __b) _NOEXCEPT : __a_(__b) {}
+    atomic_flag(bool __b) _NOEXCEPT : __a_(__b) {} // EXTENSION
 
 #ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
     atomic_flag(const atomic_flag&) = delete;
@@ -1779,6 +1820,15 @@ typedef atomic<uint_fast32_t> atomic_uint_fast32_t;
 typedef atomic<int_fast64_t>  atomic_int_fast64_t;
 typedef atomic<uint_fast64_t> atomic_uint_fast64_t;
 
+typedef atomic< int8_t>  atomic_int8_t;
+typedef atomic<uint8_t>  atomic_uint8_t;
+typedef atomic< int16_t> atomic_int16_t;
+typedef atomic<uint16_t> atomic_uint16_t;
+typedef atomic< int32_t> atomic_int32_t;
+typedef atomic<uint32_t> atomic_uint32_t;
+typedef atomic< int64_t> atomic_int64_t;
+typedef atomic<uint64_t> atomic_uint64_t;
+
 typedef atomic<intptr_t>  atomic_intptr_t;
 typedef atomic<uintptr_t> atomic_uintptr_t;
 typedef atomic<size_t>    atomic_size_t;
@@ -1789,17 +1839,6 @@ typedef atomic<uintmax_t> atomic_uintmax_t;
 #define ATOMIC_FLAG_INIT {false}
 #define ATOMIC_VAR_INIT(__v) {__v}
 
-#define ATOMIC_BOOL_LOCK_FREE      __GCC_ATOMIC_BOOL_LOCK_FREE
-#define ATOMIC_CHAR_LOCK_FREE      __GCC_ATOMIC_CHAR_LOCK_FREE
-#define ATOMIC_CHAR16_T_LOCK_FREE  __GCC_ATOMIC_CHAR16_T_LOCK_FREE
-#define ATOMIC_CHAR32_T_LOCK_FREE  __GCC_ATOMIC_CHAR32_T_LOCK_FREE
-#define ATOMIC_WCHAR_T_LOCK_FREE   __GCC_ATOMIC_WCHAR_T_LOCK_FREE
-#define ATOMIC_SHORT_LOCK_FREE     __GCC_ATOMIC_SHORT_LOCK_FREE
-#define ATOMIC_INT_LOCK_FREE       __GCC_ATOMIC_INT_LOCK_FREE
-#define ATOMIC_LONG_LOCK_FREE      __GCC_ATOMIC_LONG_LOCK_FREE
-#define ATOMIC_LLONG_LOCK_FREE     __GCC_ATOMIC_LLONG_LOCK_FREE
-#define ATOMIC_POINTER_LOCK_FREE   __GCC_ATOMIC_POINTER_LOCK_FREE
-
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_ATOMIC
diff --git a/include/bitset b/include/bitset
index 87d7afca5a73..3f9b964e45ac 100644
--- a/include/bitset
+++ b/include/bitset
@@ -656,7 +656,7 @@ __bitset<0, 0>::__bitset(unsigned long long) _NOEXCEPT
 }
 
 template <size_t _Size> class _LIBCPP_TYPE_VIS_ONLY bitset;
-template <size_t _Size> struct _LIBCPP_TYPE_VIS_ONLY hash<bitset<_Size> >;
+template <size_t _Size> struct hash<bitset<_Size> >;
 
 template <size_t _Size>
 class _LIBCPP_TYPE_VIS_ONLY bitset
diff --git a/include/cctype b/include/cctype
index a68c2a06604d..7fc81344696d 100644
--- a/include/cctype
+++ b/include/cctype
@@ -44,6 +44,63 @@ int toupper(int c);
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#ifdef isalnum
+#undef isalnum
+#endif
+
+#ifdef isalpha
+#undef isalpha
+#endif
+
+#ifdef isblank
+#undef isblank
+#endif
+
+#ifdef iscntrl
+#undef iscntrl
+#endif
+
+#ifdef isdigit
+#undef isdigit
+#endif
+
+#ifdef isgraph
+#undef isgraph
+#endif
+
+#ifdef islower
+#undef islower
+#endif
+
+#ifdef isprint
+#undef isprint
+#endif
+
+#ifdef ispunct
+#undef ispunct
+#endif
+
+#ifdef isspace
+#undef isspace
+#endif
+
+#ifdef isupper
+#undef isupper
+#endif
+
+#ifdef isxdigit
+#undef isxdigit
+#endif
+
+#ifdef tolower
+#undef tolower
+#endif
+
+#ifdef toupper
+#undef toupper
+#endif
+
+
 using ::isalnum;
 using ::isalpha;
 using ::isblank;
diff --git a/include/cmath b/include/cmath
index ebbde18168ff..b3e959405e9e 100644
--- a/include/cmath
+++ b/include/cmath
@@ -209,6 +209,10 @@ floating_point hypot (arithmetic x, arithmetic y);
 float          hypotf(float x, float y);
 long double    hypotl(long double x, long double y);
 
+double       hypot(double x, double y, double z);                // C++17
+float        hypot(float x, float y, float z);                   // C++17
+long double  hypot(long double x, long double y, long double z); // C++17
+
 int ilogb (arithmetic x);
 int ilogbf(float x);
 int ilogbl(long double x);
@@ -548,6 +552,30 @@ using ::lgamma;
 using ::lgammaf;
 #endif // __sun__
 
+#if _LIBCPP_STD_VER > 14
+inline _LIBCPP_INLINE_VISIBILITY float       hypot(       float x,       float y,       float z ) { return sqrt(x*x + y*y + z*z); }
+inline _LIBCPP_INLINE_VISIBILITY double      hypot(      double x,      double y,      double z ) { return sqrt(x*x + y*y + z*z); }
+inline _LIBCPP_INLINE_VISIBILITY long double hypot( long double x, long double y, long double z ) { return sqrt(x*x + y*y + z*z); }
+
+template <class _A1, class _A2, class _A3>
+inline _LIBCPP_INLINE_VISIBILITY
+typename std::__lazy_enable_if
+<
+    std::is_arithmetic<_A1>::value &&
+    std::is_arithmetic<_A2>::value &&
+    std::is_arithmetic<_A3>::value,
+    std::__promote<_A1, _A2, _A3>
+>::type
+hypot(_A1 __lcpp_x, _A2 __lcpp_y, _A3 __lcpp_z) _NOEXCEPT
+{
+    typedef typename std::__promote<_A1, _A2, _A3>::type __result_type;
+    static_assert((!(std::is_same<_A1, __result_type>::value &&
+                     std::is_same<_A2, __result_type>::value &&
+                     std::is_same<_A3, __result_type>::value)), "");
+    return hypot((__result_type)__lcpp_x, (__result_type)__lcpp_y, (__result_type)__lcpp_z);
+}
+#endif
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_CMATH
diff --git a/include/complex b/include/complex
index 2943da1d775c..f56138fa2d16 100644
--- a/include/complex
+++ b/include/complex
@@ -332,7 +332,9 @@ public:
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR complex(float __re = 0.0f, float __im = 0.0f)
         : __re_(__re), __im_(__im) {}
+    _LIBCPP_INLINE_VISIBILITY
     explicit _LIBCPP_CONSTEXPR complex(const complex<double>& __c);
+    _LIBCPP_INLINE_VISIBILITY
     explicit _LIBCPP_CONSTEXPR complex(const complex<long double>& __c);
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR float real() const {return __re_;}
@@ -388,7 +390,9 @@ public:
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR complex(double __re = 0.0, double __im = 0.0)
         : __re_(__re), __im_(__im) {}
+    _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR complex(const complex<float>& __c);
+    _LIBCPP_INLINE_VISIBILITY
     explicit _LIBCPP_CONSTEXPR complex(const complex<long double>& __c);
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR double real() const {return __re_;}
@@ -444,7 +448,9 @@ public:
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR complex(long double __re = 0.0L, long double __im = 0.0L)
         : __re_(__re), __im_(__im) {}
+    _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR complex(const complex<float>& __c);
+    _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR complex(const complex<double>& __c);
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR long double real() const {return __re_;}
@@ -490,32 +496,32 @@ public:
         }
 };
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 _LIBCPP_CONSTEXPR
 complex<float>::complex(const complex<double>& __c)
     : __re_(__c.real()), __im_(__c.imag()) {}
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 _LIBCPP_CONSTEXPR
 complex<float>::complex(const complex<long double>& __c)
     : __re_(__c.real()), __im_(__c.imag()) {}
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 _LIBCPP_CONSTEXPR
 complex<double>::complex(const complex<float>& __c)
     : __re_(__c.real()), __im_(__c.imag()) {}
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 _LIBCPP_CONSTEXPR
 complex<double>::complex(const complex<long double>& __c)
     : __re_(__c.real()), __im_(__c.imag()) {}
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 _LIBCPP_CONSTEXPR
 complex<long double>::complex(const complex<float>& __c)
     : __re_(__c.real()), __im_(__c.imag()) {}
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 _LIBCPP_CONSTEXPR
 complex<long double>::complex(const complex<double>& __c)
     : __re_(__c.real()), __im_(__c.imag()) {}
@@ -1399,7 +1405,7 @@ acos(const complex<_Tp>& __x)
     }
     if (isinf(__x.imag()))
         return complex<_Tp>(__pi/_Tp(2), -__x.imag());
-    if (__x.real() == 0)
+    if (__x.real() == 0 && (__x.imag() == 0 || isnan(__x.imag())))
         return complex<_Tp>(__pi/_Tp(2), -__x.imag());
     complex<_Tp> __z = log(__x + sqrt(pow(__x, _Tp(2)) - _Tp(1)));
     if (signbit(__x.imag()))
diff --git a/include/cstring b/include/cstring
index d60b9923c6c2..d550695caa42 100644
--- a/include/cstring
+++ b/include/cstring
@@ -78,30 +78,13 @@ using ::strcmp;
 using ::strncmp;
 using ::strcoll;
 using ::strxfrm;
-
 using ::memchr;
-
 using ::strchr;
-
 using ::strcspn;
-
 using ::strpbrk;
-
 using ::strrchr;
-
 using ::strspn;
-
 using ::strstr;
-
-// MSVCRT, GNU libc and its derivates already have the correct prototype in <string.h> #ifdef __cplusplus
-#if !defined(__GLIBC__) && !defined(_LIBCPP_MSVCRT) && !defined(__sun__) && !defined(_STRING_H_CPLUSPLUS_98_CONFORMANCE_)
-inline _LIBCPP_INLINE_VISIBILITY       char* strchr(      char* __s, int __c) {return ::strchr(__s, __c);}
-inline _LIBCPP_INLINE_VISIBILITY       char* strpbrk(      char* __s1, const char* __s2) {return ::strpbrk(__s1, __s2);}
-inline _LIBCPP_INLINE_VISIBILITY       char* strrchr(      char* __s, int __c) {return ::strrchr(__s, __c);}
-inline _LIBCPP_INLINE_VISIBILITY       void* memchr(      void* __s, int __c, size_t __n) {return ::memchr(__s, __c, __n);}
-inline _LIBCPP_INLINE_VISIBILITY       char* strstr(      char* __s1, const char* __s2) {return ::strstr(__s1, __s2);}
-#endif
-
 #ifndef _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS
 using ::strtok;
 #endif
diff --git a/include/cwchar b/include/cwchar
index ef4806db2bde..52dde9e18021 100644
--- a/include/cwchar
+++ b/include/cwchar
@@ -157,30 +157,11 @@ using ::wcscmp;
 using ::wcscoll;
 using ::wcsncmp;
 using ::wcsxfrm;
-
-#ifdef _LIBCPP_WCHAR_H_HAS_CONST_OVERLOADS
 using ::wcschr;
 using ::wcspbrk;
 using ::wcsrchr;
 using ::wcsstr;
 using ::wmemchr;
-#else
-inline _LIBCPP_INLINE_VISIBILITY const wchar_t* wcschr(const wchar_t* __s, wchar_t __c) {return ::wcschr(__s, __c);}
-inline _LIBCPP_INLINE_VISIBILITY       wchar_t* wcschr(      wchar_t* __s, wchar_t __c) {return ::wcschr(__s, __c);}
-
-inline _LIBCPP_INLINE_VISIBILITY const wchar_t* wcspbrk(const wchar_t* __s1, const wchar_t* __s2) {return ::wcspbrk(__s1, __s2);}
-inline _LIBCPP_INLINE_VISIBILITY       wchar_t* wcspbrk(      wchar_t* __s1, const wchar_t* __s2) {return ::wcspbrk(__s1, __s2);}
-
-inline _LIBCPP_INLINE_VISIBILITY const wchar_t* wcsrchr(const wchar_t* __s, wchar_t __c) {return ::wcsrchr(__s, __c);}
-inline _LIBCPP_INLINE_VISIBILITY       wchar_t* wcsrchr(      wchar_t* __s, wchar_t __c) {return ::wcsrchr(__s, __c);}
-
-inline _LIBCPP_INLINE_VISIBILITY const wchar_t* wcsstr(const wchar_t* __s1, const wchar_t* __s2) {return ::wcsstr(__s1, __s2);}
-inline _LIBCPP_INLINE_VISIBILITY       wchar_t* wcsstr(      wchar_t* __s1, const wchar_t* __s2) {return ::wcsstr(__s1, __s2);}
-
-inline _LIBCPP_INLINE_VISIBILITY const wchar_t* wmemchr(const wchar_t* __s, wchar_t __c, size_t __n) {return ::wmemchr(__s, __c, __n);}
-inline _LIBCPP_INLINE_VISIBILITY       wchar_t* wmemchr(      wchar_t* __s, wchar_t __c, size_t __n) {return ::wmemchr(__s, __c, __n);}
-#endif
-
 using ::wcscspn;
 using ::wcslen;
 using ::wcsspn;
diff --git a/include/deque b/include/deque
index c6fbd512a1c6..57650427645c 100644
--- a/include/deque
+++ b/include/deque
@@ -2026,7 +2026,7 @@ deque<_Tp, _Allocator>::emplace(const_iterator __p, _Args&&... __args)
         }
         else
         {
-            value_type __tmp(_VSTD::forward<_Args>(__args)...);
+            __temp_value<value_type, _Allocator> __tmp(this->__alloc(), _VSTD::forward<_Args>(__args)...);
             iterator __b = __base::begin();
             iterator __bm1 = _VSTD::prev(__b);
             __alloc_traits::construct(__a, _VSTD::addressof(*__bm1), _VSTD::move(*__b));
@@ -2034,7 +2034,7 @@ deque<_Tp, _Allocator>::emplace(const_iterator __p, _Args&&... __args)
             ++__base::size();
             if (__pos > 1)
                 __b = _VSTD::move(_VSTD::next(__b), __b + __pos, __b);
-            *__b = _VSTD::move(__tmp);
+            *__b = _VSTD::move(__tmp.get());
         }
     }
     else
@@ -2050,14 +2050,14 @@ deque<_Tp, _Allocator>::emplace(const_iterator __p, _Args&&... __args)
         }
         else
         {
-            value_type __tmp(_VSTD::forward<_Args>(__args)...);
+            __temp_value<value_type, _Allocator> __tmp(this->__alloc(), _VSTD::forward<_Args>(__args)...);
             iterator __e = __base::end();
             iterator __em1 = _VSTD::prev(__e);
             __alloc_traits::construct(__a, _VSTD::addressof(*__e), _VSTD::move(*__em1));
             ++__base::size();
             if (__de > 1)
                 __e = _VSTD::move_backward(__e - __de, __em1, __e);
-            *--__e = _VSTD::move(__tmp);
+            *--__e = _VSTD::move(__tmp.get());
         }
     }
     return __base::begin() + __pos;
diff --git a/include/exception b/include/exception
index 686e4ecd0578..186d379f08f5 100644
--- a/include/exception
+++ b/include/exception
@@ -80,6 +80,10 @@ template <class E> void rethrow_if_nested(const E& e);
 #include <__config>
 #include <cstddef>
 #include <type_traits>
+#if defined(_LIBCPP_NO_EXCEPTIONS)
+#include <cstdio>
+#include <cstdlib>
+#endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
@@ -251,4 +255,19 @@ rethrow_if_nested(const _Ep&, typename enable_if<
 
 }  // std
 
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Exception>
+_LIBCPP_INLINE_VISIBILITY
+inline void __libcpp_throw(_Exception const& __e) {
+#ifndef _LIBCPP_NO_EXCEPTIONS
+    throw __e;
+#else
+    _VSTD::fprintf(stderr, "%s\n", __e.what());
+    _VSTD::abort();
+#endif
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
 #endif  // _LIBCPP_EXCEPTION
diff --git a/include/experimental/__config b/include/experimental/__config
index f64a3a90cd12..9a7bbe85d8d3 100644
--- a/include/experimental/__config
+++ b/include/experimental/__config
@@ -25,8 +25,26 @@
 #define _LIBCPP_END_NAMESPACE_LFTS  } } }
 #define _VSTD_LFTS _VSTD_EXPERIMENTAL::fundamentals_v1
 
+#define _LIBCPP_BEGIN_NAMESPACE_LFTS_V2 _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace fundamentals_v2 {
+#define _LIBCPP_END_NAMESPACE_LFTS_V2  } } }
+#define _VSTD_LFTS_V2 _VSTD_EXPERIMENTAL::fundamentals_v2
+
+#define _LIBCPP_BEGIN_NAMESPACE_LFTS_PMR _LIBCPP_BEGIN_NAMESPACE_LFTS namespace pmr {
+#define _LIBCPP_END_NAMESPACE_LFTS_PMR _LIBCPP_END_NAMESPACE_LFTS }
+#define _VSTD_LFTS_PMR _VSTD_LFTS::pmr
+
 #define _LIBCPP_BEGIN_NAMESPACE_CHRONO_LFTS _LIBCPP_BEGIN_NAMESPACE_STD        \
   namespace chrono { namespace experimental { inline namespace fundamentals_v1 {
 #define _LIBCPP_END_NAMESPACE_CHRONO_LFTS _LIBCPP_END_NAMESPACE_STD } } }
 
+#define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM \
+    _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL namespace filesystem { \
+    inline namespace v1 {
+
+#define _LIBCPP_END_NAMESPACE_EXPERIMENTAL_FILESYSTEM \
+    } } _LIBCPP_END_NAMESPACE_EXPERIMENTAL
+
+
+#define _VSTD_FS ::std::experimental::filesystem::v1
+
 #endif
diff --git a/include/experimental/__memory b/include/experimental/__memory
new file mode 100644
index 000000000000..229fea605bfd
--- /dev/null
+++ b/include/experimental/__memory
@@ -0,0 +1,90 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPERIMENTAL___MEMORY
+#define _LIBCPP_EXPERIMENTAL___MEMORY
+
+#include <experimental/__config>
+#include <experimental/utility> // for erased_type
+#include <__functional_base>
+#include <type_traits>
+
+_LIBCPP_BEGIN_NAMESPACE_LFTS
+
+template <
+    class _Tp, class _Alloc
+  , bool = uses_allocator<_Tp, _Alloc>::value
+  , bool = __has_allocator_type<_Tp>::value
+  >
+struct __lfts_uses_allocator : public false_type {};
+
+template <class _Tp, class _Alloc>
+struct __lfts_uses_allocator<_Tp, _Alloc, false, false> : public false_type {};
+
+template <class _Tp, class _Alloc, bool HasAlloc>
+struct __lfts_uses_allocator<_Tp, _Alloc, true, HasAlloc> : public true_type {};
+
+template <class _Tp, class _Alloc>
+struct __lfts_uses_allocator<_Tp, _Alloc, false, true>
+  : public integral_constant<bool
+    , is_convertible<_Alloc, typename _Tp::allocator_type>::value
+      || is_same<erased_type, typename _Tp::allocator_type>::value
+    >
+{};
+
+template <bool _UsesAlloc, class _Tp, class _Alloc, class ..._Args>
+struct __lfts_uses_alloc_ctor_imp
+{
+    static const int value = 0;
+};
+
+template <class _Tp, class _Alloc, class ..._Args>
+struct __lfts_uses_alloc_ctor_imp<true, _Tp, _Alloc, _Args...>
+{
+    static const bool __ic_first
+        = is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value;
+
+    static const bool __ic_second =
+        conditional<
+            __ic_first,
+            false_type,
+            is_constructible<_Tp, _Args..., _Alloc>
+        >::type::value;
+
+    static_assert(__ic_first || __ic_second,
+                  "Request for uses allocator construction is ill-formed");
+
+    static const int value = __ic_first ? 1 : 2;
+};
+
+template <class _Tp, class _Alloc, class ..._Args>
+struct __lfts_uses_alloc_ctor
+  : integral_constant<int,
+        __lfts_uses_alloc_ctor_imp<
+            __lfts_uses_allocator<_Tp, _Alloc>::value
+          , _Tp, _Alloc, _Args...
+        >::value
+    >
+{};
+
+template <class _Tp, class _Alloc, class ..._Args>
+inline _LIBCPP_INLINE_VISIBILITY
+void __lfts_user_alloc_construct(
+    _Tp * __store, const _Alloc & __a, _Args &&... __args)
+{
+    _VSTD::__user_alloc_construct_impl(
+        typename __lfts_uses_alloc_ctor<_Tp, _Alloc, _Args...>::type()
+       , __store, __a, _VSTD::forward<_Args>(__args)...
+       );
+}
+
+_LIBCPP_END_NAMESPACE_LFTS
+
+#endif /* _LIBCPP_EXPERIMENTAL___MEMORY */
diff --git a/include/experimental/algorithm b/include/experimental/algorithm
index ffaa793b6d4e..3902111c54ea 100644
--- a/include/experimental/algorithm
+++ b/include/experimental/algorithm
@@ -53,7 +53,7 @@ _LIBCPP_BEGIN_NAMESPACE_LFTS
 template <class _ForwardIterator, class _Searcher>
 _LIBCPP_INLINE_VISIBILITY
 _ForwardIterator search(_ForwardIterator __f, _ForwardIterator __l, const _Searcher &__s)
-{ return __s(__f, __l); }
+{ return __s(__f, __l).first; }
 
 
 template <class _PopulationIterator, class _SampleIterator, class _Distance,
diff --git a/include/experimental/any b/include/experimental/any
index 603788484dd5..4c732496c52b 100644
--- a/include/experimental/any
+++ b/include/experimental/any
@@ -113,10 +113,12 @@ class any;
 
 template <class _ValueType>
 typename add_pointer<typename add_const<_ValueType>::type>::type
+_LIBCPP_INLINE_VISIBILITY
 any_cast(any const *) _NOEXCEPT;
 
 template <class _ValueType>
 typename add_pointer<_ValueType>::type
+_LIBCPP_INLINE_VISIBILITY
 any_cast(any *) _NOEXCEPT;
 
 namespace __any_imp
@@ -185,6 +187,7 @@ public:
       class _ValueType
     , class = __any_imp::_EnableIfNotAny<_ValueType>
     >
+  _LIBCPP_INLINE_VISIBILITY
   any(_ValueType && __value);
 
   _LIBCPP_INLINE_VISIBILITY
@@ -212,6 +215,7 @@ public:
       class _ValueType
     , class = __any_imp::_EnableIfNotAny<_ValueType>
     >
+  _LIBCPP_INLINE_VISIBILITY
   any & operator=(_ValueType && __rhs);
 
   // 6.3.3 any modifiers
@@ -221,6 +225,7 @@ public:
     if (__h) this->__call(_Action::_Destroy);
   }
 
+  _LIBCPP_INLINE_VISIBILITY
   void swap(any & __rhs) _NOEXCEPT;
 
   // 6.3.4 any observers
@@ -457,7 +462,6 @@ namespace __any_imp
 
 
 template <class _ValueType, class>
-_LIBCPP_INLINE_VISIBILITY
 any::any(_ValueType && __v) : __h(nullptr)
 {
   typedef typename decay<_ValueType>::type _Tp;
@@ -468,7 +472,6 @@ any::any(_ValueType && __v) : __h(nullptr)
 }
 
 template <class _ValueType, class>
-_LIBCPP_INLINE_VISIBILITY
 any & any::operator=(_ValueType && __v)
 {
   typedef typename decay<_ValueType>::type _Tp;
@@ -478,7 +481,7 @@ any & any::operator=(_ValueType && __v)
   return *this;
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void any::swap(any & __rhs) _NOEXCEPT
 {
     if (__h && __rhs.__h) {
@@ -550,7 +553,7 @@ _ValueType any_cast(any && __v)
 }
 
 template <class _ValueType>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename add_pointer<typename add_const<_ValueType>::type>::type
 any_cast(any const * __any) _NOEXCEPT
 {
@@ -560,7 +563,6 @@ any_cast(any const * __any) _NOEXCEPT
 }
 
 template <class _ValueType>
-_LIBCPP_INLINE_VISIBILITY
 typename add_pointer<_ValueType>::type
 any_cast(any * __any) _NOEXCEPT
 {
diff --git a/include/experimental/deque b/include/experimental/deque
new file mode 100644
index 000000000000..f8495743c1f9
--- /dev/null
+++ b/include/experimental/deque
@@ -0,0 +1,47 @@
+// -*- C++ -*-
+//===--------------------------- deque ------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPERIMENTAL_DEQUE
+#define _LIBCPP_EXPERIMENTAL_DEQUE
+/*
+    experimental/deque synopsis
+
+// C++1z
+namespace std {
+namespace experimental {
+inline namespace fundamentals_v1 {
+namespace pmr {
+
+  template <class T>
+  using deque = std::deque<T,polymorphic_allocator<T>>;
+
+} // namespace pmr
+} // namespace fundamentals_v1
+} // namespace experimental
+} // namespace std
+
+ */
+
+#include <experimental/__config>
+#include <deque>
+#include <experimental/memory_resource>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
+
+template <class _ValueT>
+using deque = _VSTD::deque<_ValueT, polymorphic_allocator<_ValueT>>;
+
+_LIBCPP_END_NAMESPACE_LFTS_PMR
+
+#endif /* _LIBCPP_EXPERIMENTAL_DEQUE */
diff --git a/include/experimental/dynarray b/include/experimental/dynarray
index f40a6ca188b8..4a06908e11b1 100644
--- a/include/experimental/dynarray
+++ b/include/experimental/dynarray
@@ -159,9 +159,13 @@ private:
 
 public:
 
+    _LIBCPP_INLINE_VISIBILITY
     explicit dynarray(size_type __c);
+    _LIBCPP_INLINE_VISIBILITY
     dynarray(size_type __c, const value_type& __v);
+    _LIBCPP_INLINE_VISIBILITY
     dynarray(const dynarray& __d);
+    _LIBCPP_INLINE_VISIBILITY
     dynarray(initializer_list<value_type>);
 
 //  We're not implementing these right now.
@@ -176,6 +180,7 @@ public:
 //       dynarray(allocator_arg_t, const _Alloc& __alloc, initializer_list<value_type>);
 
     dynarray& operator=(const dynarray&) = delete;
+    _LIBCPP_INLINE_VISIBILITY
     ~dynarray();
 
     // iterators:
@@ -219,7 +224,7 @@ public:
 };
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 dynarray<_Tp>::dynarray(size_type __c) : dynarray ()
 {
     __base_ = __allocate (__c);
@@ -229,7 +234,7 @@ dynarray<_Tp>::dynarray(size_type __c) : dynarray ()
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 dynarray<_Tp>::dynarray(size_type __c, const value_type& __v) : dynarray ()
 {
     __base_ = __allocate (__c);
@@ -239,7 +244,7 @@ dynarray<_Tp>::dynarray(size_type __c, const value_type& __v) : dynarray ()
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 dynarray<_Tp>::dynarray(initializer_list<value_type> __il) : dynarray ()
 {
     size_t sz = __il.size();
@@ -251,7 +256,7 @@ dynarray<_Tp>::dynarray(initializer_list<value_type> __il) : dynarray ()
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 dynarray<_Tp>::dynarray(const dynarray& __d) : dynarray ()
 {
     size_t sz = __d.size();
@@ -263,7 +268,7 @@ dynarray<_Tp>::dynarray(const dynarray& __d) : dynarray ()
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 dynarray<_Tp>::~dynarray()
 { 
     value_type *__data = data () + __size_;
diff --git a/include/experimental/filesystem b/include/experimental/filesystem
new file mode 100644
index 000000000000..7de93fdf8f15
--- /dev/null
+++ b/include/experimental/filesystem
@@ -0,0 +1,2052 @@
+// -*- C++ -*-
+//===--------------------------- filesystem -------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+#ifndef _LIBCPP_EXPERIMENTAL_FILESYSTEM
+#define _LIBCPP_EXPERIMENTAL_FILESYSTEM
+/*
+    filesystem synopsis
+
+    namespace std { namespace experimental { namespace filesystem { inline namespace v1 {
+
+    class path;
+
+    void swap(path& lhs, path& rhs) _NOEXCEPT;
+    size_t hash_value(const path& p) _NOEXCEPT;
+
+    bool operator==(const path& lhs, const path& rhs) _NOEXCEPT;
+    bool operator!=(const path& lhs, const path& rhs) _NOEXCEPT;
+    bool operator< (const path& lhs, const path& rhs) _NOEXCEPT;
+    bool operator<=(const path& lhs, const path& rhs) _NOEXCEPT;
+    bool operator> (const path& lhs, const path& rhs) _NOEXCEPT;
+    bool operator>=(const path& lhs, const path& rhs) _NOEXCEPT;
+
+    path operator/ (const path& lhs, const path& rhs);
+
+    template <class charT, class traits>
+    basic_ostream<charT, traits>&
+    operator<<(basic_ostream<charT, traits>& os, const path& p);
+
+    template <class charT, class traits>
+    basic_istream<charT, traits>&
+    operator>>(basic_istream<charT, traits>& is, path& p);
+
+    template <class Source>
+      path u8path(const Source& source);
+    template <class InputIterator>
+      path u8path(InputIterator first, InputIterator last);
+
+    class filesystem_error;
+    class directory_entry;
+
+    class directory_iterator;
+
+    // enable directory_iterator range-based for statements
+    directory_iterator begin(directory_iterator iter) noexcept;
+    directory_iterator end(const directory_iterator&) noexcept;
+
+    class recursive_directory_iterator;
+
+    // enable recursive_directory_iterator range-based for statements
+    recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept;
+    recursive_directory_iterator end(const recursive_directory_iterator&) noexcept;
+
+    class file_status;
+
+    struct space_info
+    {
+      uintmax_t capacity;
+      uintmax_t free;
+      uintmax_t available;
+    };
+
+    enum class file_type;
+    enum class perms;
+    enum class copy_options;
+    enum class directory_options;
+
+    typedef chrono::time_point<trivial-clock>  file_time_type;
+
+    // operational functions
+
+    path absolute(const path& p, const path& base=current_path());
+
+    path canonical(const path& p, const path& base = current_path());
+    path canonical(const path& p, error_code& ec);
+    path canonical(const path& p, const path& base, error_code& ec);
+
+    void copy(const path& from, const path& to);
+    void copy(const path& from, const path& to, error_code& ec) _NOEXCEPT;
+    void copy(const path& from, const path& to, copy_options options);
+    void copy(const path& from, const path& to, copy_options options,
+                   error_code& ec) _NOEXCEPT;
+
+    bool copy_file(const path& from, const path& to);
+    bool copy_file(const path& from, const path& to, error_code& ec) _NOEXCEPT;
+    bool copy_file(const path& from, const path& to, copy_options option);
+    bool copy_file(const path& from, const path& to, copy_options option,
+                           error_code& ec) _NOEXCEPT;
+
+    void copy_symlink(const path& existing_symlink, const path& new_symlink);
+    void copy_symlink(const path& existing_symlink, const path& new_symlink,
+                              error_code& ec) _NOEXCEPT;
+
+    bool create_directories(const path& p);
+    bool create_directories(const path& p, error_code& ec) _NOEXCEPT;
+
+    bool create_directory(const path& p);
+    bool create_directory(const path& p, error_code& ec) _NOEXCEPT;
+
+    bool create_directory(const path& p, const path& attributes);
+    bool create_directory(const path& p, const path& attributes,
+                                  error_code& ec) _NOEXCEPT;
+
+    void create_directory_symlink(const path& to, const path& new_symlink);
+    void create_directory_symlink(const path& to, const path& new_symlink,
+                                          error_code& ec) _NOEXCEPT;
+
+    void create_hard_link(const path& to, const path& new_hard_link);
+    void create_hard_link(const path& to, const path& new_hard_link,
+                                  error_code& ec) _NOEXCEPT;
+
+    void create_symlink(const path& to, const path& new_symlink);
+    void create_symlink(const path& to, const path& new_symlink,
+                                error_code& ec) _NOEXCEPT;
+
+    path current_path();
+    path current_path(error_code& ec);
+    void current_path(const path& p);
+    void current_path(const path& p, error_code& ec) _NOEXCEPT;
+
+    bool exists(file_status s) _NOEXCEPT;
+    bool exists(const path& p);
+    bool exists(const path& p, error_code& ec) _NOEXCEPT;
+
+    bool equivalent(const path& p1, const path& p2);
+    bool equivalent(const path& p1, const path& p2, error_code& ec) _NOEXCEPT;
+
+    uintmax_t    file_size(const path& p);
+    uintmax_t    file_size(const path& p, error_code& ec) _NOEXCEPT;
+
+    uintmax_t    hard_link_count(const path& p);
+    uintmax_t    hard_link_count(const path& p, error_code& ec) _NOEXCEPT;
+
+    bool is_block_file(file_status s) _NOEXCEPT;
+    bool is_block_file(const path& p);
+    bool is_block_file(const path& p, error_code& ec) _NOEXCEPT;
+
+    bool is_character_file(file_status s) _NOEXCEPT;
+    bool is_character_file(const path& p);
+    bool is_character_file(const path& p, error_code& ec) _NOEXCEPT;
+
+    bool is_directory(file_status s) _NOEXCEPT;
+    bool is_directory(const path& p);
+    bool is_directory(const path& p, error_code& ec) _NOEXCEPT;
+
+    bool is_empty(const path& p);
+    bool is_empty(const path& p, error_code& ec) _NOEXCEPT;
+
+    bool is_fifo(file_status s) _NOEXCEPT;
+    bool is_fifo(const path& p);
+    bool is_fifo(const path& p, error_code& ec) _NOEXCEPT;
+
+    bool is_other(file_status s) _NOEXCEPT;
+    bool is_other(const path& p);
+    bool is_other(const path& p, error_code& ec) _NOEXCEPT;
+
+    bool is_regular_file(file_status s) _NOEXCEPT;
+    bool is_regular_file(const path& p);
+    bool is_regular_file(const path& p, error_code& ec) _NOEXCEPT;
+
+    bool is_socket(file_status s) _NOEXCEPT;
+    bool is_socket(const path& p);
+    bool is_socket(const path& p, error_code& ec) _NOEXCEPT;
+
+    bool is_symlink(file_status s) _NOEXCEPT;
+    bool is_symlink(const path& p);
+    bool is_symlink(const path& p, error_code& ec) _NOEXCEPT;
+
+    file_time_type  last_write_time(const path& p);
+    file_time_type  last_write_time(const path& p, error_code& ec) _NOEXCEPT;
+    void last_write_time(const path& p, file_time_type new_time);
+    void last_write_time(const path& p, file_time_type new_time,
+                                 error_code& ec) _NOEXCEPT;
+
+    void permissions(const path& p, perms prms);
+    void permissions(const path& p, perms prms, error_code& ec) _NOEXCEPT;
+
+    path read_symlink(const path& p);
+    path read_symlink(const path& p, error_code& ec);
+
+    bool remove(const path& p);
+    bool remove(const path& p, error_code& ec) _NOEXCEPT;
+
+    uintmax_t    remove_all(const path& p);
+    uintmax_t    remove_all(const path& p, error_code& ec) _NOEXCEPT;
+
+    void rename(const path& from, const path& to);
+    void rename(const path& from, const path& to, error_code& ec) _NOEXCEPT;
+
+    void resize_file(const path& p, uintmax_t size);
+    void resize_file(const path& p, uintmax_t size, error_code& ec) _NOEXCEPT;
+
+    space_info   space(const path& p);
+    space_info   space(const path& p, error_code& ec) _NOEXCEPT;
+
+    file_status  status(const path& p);
+    file_status  status(const path& p, error_code& ec) _NOEXCEPT;
+
+    bool status_known(file_status s) _NOEXCEPT;
+
+    file_status  symlink_status(const path& p);
+    file_status  symlink_status(const path& p, error_code& ec) _NOEXCEPT;
+
+    path system_complete(const path& p);
+    path system_complete(const path& p, error_code& ec);
+
+    path temp_directory_path();
+    path temp_directory_path(error_code& ec);
+
+} } } }  // namespaces std::experimental::filesystem::v1
+
+*/
+
+#include <experimental/__config>
+#include <cstddef>
+#include <chrono>
+#include <iterator>
+#include <iosfwd>
+#include <locale>
+#include <memory>
+#include <stack>
+#include <string>
+#include <system_error>
+#include <utility>
+#include <iomanip> // for quoted
+#include <experimental/string_view>
+
+#include <__debug>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+#define __cpp_lib_experimental_filesystem 201406
+
+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM
+
+typedef chrono::time_point<std::chrono::system_clock>  file_time_type;
+
+struct _LIBCPP_TYPE_VIS space_info
+{
+  uintmax_t capacity;
+  uintmax_t free;
+  uintmax_t available;
+};
+
+enum class _LIBCPP_TYPE_VIS file_type : signed char
+{
+    none       = 0,
+    not_found  = -1,
+    regular    = 1,
+    directory  = 2,
+    symlink    = 3,
+    block      = 4,
+    character  = 5,
+    fifo       = 6,
+    socket     = 7,
+    unknown    = 8
+};
+
+enum class _LIBCPP_TYPE_VIS perms : unsigned
+{
+    none         = 0,
+
+    owner_read   = 0400,
+    owner_write  = 0200,
+    owner_exec   = 0100,
+    owner_all    = 0700,
+
+    group_read   = 040,
+    group_write  = 020,
+    group_exec   = 010,
+    group_all    = 070,
+
+    others_read  = 04,
+    others_write = 02,
+    others_exec  = 01,
+    others_all   = 07,
+
+    all          = 0777,
+
+    set_uid      = 04000,
+    set_gid      = 02000,
+    sticky_bit   = 01000,
+    mask         = 07777,
+    unknown      = 0xFFFF,
+
+    add_perms        = 0x10000,
+    remove_perms     = 0x20000,
+    symlink_nofollow = 0x40000
+};
+
+_LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_CONSTEXPR perms operator&(perms _LHS, perms _RHS)
+{ return static_cast<perms>(static_cast<unsigned>(_LHS) & static_cast<unsigned>(_RHS)); }
+
+_LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_CONSTEXPR perms operator|(perms _LHS, perms _RHS)
+{ return static_cast<perms>(static_cast<unsigned>(_LHS) | static_cast<unsigned>(_RHS)); }
+
+_LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_CONSTEXPR perms operator^(perms _LHS, perms _RHS)
+{ return static_cast<perms>(static_cast<unsigned>(_LHS) ^ static_cast<unsigned>(_RHS)); }
+
+_LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_CONSTEXPR perms operator~(perms _LHS)
+{ return static_cast<perms>(~static_cast<unsigned>(_LHS)); }
+
+_LIBCPP_INLINE_VISIBILITY
+inline perms& operator&=(perms& _LHS, perms _RHS)
+{ return _LHS = _LHS & _RHS; }
+
+_LIBCPP_INLINE_VISIBILITY
+inline perms& operator|=(perms& _LHS, perms _RHS)
+{ return _LHS = _LHS | _RHS; }
+
+_LIBCPP_INLINE_VISIBILITY
+inline perms& operator^=(perms& _LHS, perms _RHS)
+{ return _LHS = _LHS ^ _RHS; }
+
+enum class _LIBCPP_TYPE_VIS copy_options : unsigned short
+{
+    none               = 0,
+    skip_existing      = 1,
+    overwrite_existing = 2,
+    update_existing    = 4,
+    recursive          = 8,
+    copy_symlinks      = 16,
+    skip_symlinks      = 32,
+    directories_only   = 64,
+    create_symlinks    = 128,
+    create_hard_links  = 256,
+    __in_recursive_copy = 512,
+};
+
+_LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_CONSTEXPR copy_options operator&(copy_options _LHS, copy_options _RHS)
+{ return static_cast<copy_options>(static_cast<unsigned short>(_LHS) & static_cast<unsigned short>(_RHS)); }
+
+_LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_CONSTEXPR copy_options operator|(copy_options _LHS, copy_options _RHS)
+{ return static_cast<copy_options>(static_cast<unsigned short>(_LHS) | static_cast<unsigned short>(_RHS)); }
+
+_LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_CONSTEXPR copy_options operator^(copy_options _LHS, copy_options _RHS)
+{ return static_cast<copy_options>(static_cast<unsigned short>(_LHS) ^ static_cast<unsigned short>(_RHS)); }
+
+_LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_CONSTEXPR copy_options operator~(copy_options _LHS)
+{ return static_cast<copy_options>(~static_cast<unsigned short>(_LHS)); }
+
+_LIBCPP_INLINE_VISIBILITY
+inline copy_options& operator&=(copy_options& _LHS, copy_options _RHS)
+{ return _LHS = _LHS & _RHS; }
+
+_LIBCPP_INLINE_VISIBILITY
+inline copy_options& operator|=(copy_options& _LHS, copy_options _RHS)
+{ return _LHS = _LHS | _RHS; }
+
+_LIBCPP_INLINE_VISIBILITY
+inline copy_options& operator^=(copy_options& _LHS, copy_options _RHS)
+{ return _LHS = _LHS ^ _RHS; }
+
+
+enum class directory_options : unsigned char
+{
+    none                     = 0,
+    follow_directory_symlink = 1,
+    skip_permission_denied   = 2
+};
+
+_LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_CONSTEXPR directory_options operator&(directory_options _LHS, directory_options _RHS)
+{ return static_cast<directory_options>(static_cast<unsigned char>(_LHS) & static_cast<unsigned char>(_RHS)); }
+
+_LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_CONSTEXPR directory_options operator|(directory_options _LHS, directory_options _RHS)
+{ return static_cast<directory_options>(static_cast<unsigned char>(_LHS) | static_cast<unsigned char>(_RHS)); }
+
+_LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_CONSTEXPR directory_options operator^(directory_options _LHS, directory_options _RHS)
+{ return static_cast<directory_options>(static_cast<unsigned char>(_LHS) ^ static_cast<unsigned char>(_RHS)); }
+
+_LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_CONSTEXPR directory_options operator~(directory_options _LHS)
+{ return static_cast<directory_options>(~static_cast<unsigned char>(_LHS)); }
+
+_LIBCPP_INLINE_VISIBILITY
+inline directory_options& operator&=(directory_options& _LHS, directory_options _RHS)
+{ return _LHS = _LHS & _RHS; }
+
+_LIBCPP_INLINE_VISIBILITY
+inline directory_options& operator|=(directory_options& _LHS, directory_options _RHS)
+{ return _LHS = _LHS | _RHS; }
+
+_LIBCPP_INLINE_VISIBILITY
+inline directory_options& operator^=(directory_options& _LHS, directory_options _RHS)
+{ return _LHS = _LHS ^ _RHS; }
+
+
+class _LIBCPP_TYPE_VIS file_status
+{
+public:
+    // constructors
+    _LIBCPP_INLINE_VISIBILITY
+    explicit file_status(file_type __ft = file_type::none,
+                         perms __prms   = perms::unknown) _NOEXCEPT
+      : __ft_(__ft), __prms_(__prms)
+    {}
+
+    file_status(const file_status&) _NOEXCEPT = default;
+    file_status(file_status&&) _NOEXCEPT = default;
+
+    _LIBCPP_INLINE_VISIBILITY
+    ~file_status() {}
+
+    file_status& operator=(const file_status&) _NOEXCEPT = default;
+    file_status& operator=(file_status&&) _NOEXCEPT = default;
+
+    // observers
+    _LIBCPP_ALWAYS_INLINE
+    file_type type() const _NOEXCEPT {
+        return __ft_;
+    }
+
+    _LIBCPP_ALWAYS_INLINE
+    perms permissions() const _NOEXCEPT {
+        return __prms_;
+    }
+
+    // modifiers
+    _LIBCPP_ALWAYS_INLINE
+    void type(file_type __ft) _NOEXCEPT {
+        __ft_ = __ft;
+    }
+
+    _LIBCPP_ALWAYS_INLINE
+    void permissions(perms __p) _NOEXCEPT {
+        __prms_ = __p;
+    }
+private:
+    file_type __ft_;
+    perms __prms_;
+};
+
+class _LIBCPP_TYPE_VIS directory_entry;
+
+template <class _Tp> struct __can_convert_char {
+  static const bool value = false;
+};
+template <> struct __can_convert_char<char> {
+    static const bool value = true;
+    using __char_type = char;
+};
+template <> struct __can_convert_char<wchar_t>  {
+    static const bool value = true;
+    using __char_type = wchar_t;
+};
+template <> struct __can_convert_char<char16_t> {
+    static const bool value = true;
+    using __char_type = char16_t;
+};
+template <> struct __can_convert_char<char32_t> {
+    static const bool value = true;
+    using __char_type = char32_t;
+};
+
+template <class _ECharT>
+typename enable_if<__can_convert_char<_ECharT>::value, bool>::type
+__is_separator(_ECharT __e) {
+    return __e == _ECharT('/');
+};
+
+struct _NullSentinal {};
+
+template <class _Tp>
+using _Void = void;
+
+template <class _Tp, class = void>
+struct __is_pathable_string : public false_type {};
+
+template <class _ECharT, class _Traits, class _Alloc>
+struct __is_pathable_string<basic_string<_ECharT, _Traits, _Alloc>,
+                            _Void<typename __can_convert_char<_ECharT>::__char_type>>
+: public __can_convert_char<_ECharT>
+{
+    using _Str = basic_string<_ECharT, _Traits, _Alloc>;
+    using _Base = __can_convert_char<_ECharT>;
+    static _ECharT const* __range_begin(_Str const& __s) { return __s.data(); }
+    static _ECharT const* __range_end(_Str const& __s) { return __s.data() + __s.length(); }
+    static _ECharT __first_or_null(_Str const& __s) {
+        return __s.empty() ? _ECharT{} : __s[0];
+    }
+};
+
+template <class _Source,
+          class _DS = typename decay<_Source>::type,
+          class _UnqualPtrType = typename remove_const<
+              typename remove_pointer<_DS>::type>::type,
+          bool _IsCharPtr = is_pointer<_DS>::value &&
+                            __can_convert_char<_UnqualPtrType>::value
+        >
+struct __is_pathable_char_array : false_type {};
+
+template <class _Source, class _ECharT, class _UPtr>
+struct __is_pathable_char_array<_Source, _ECharT*, _UPtr, true>
+        : __can_convert_char<typename remove_const<_ECharT>::type>
+{
+  using _Base = __can_convert_char<typename remove_const<_ECharT>::type>;
+
+  static _ECharT const* __range_begin(const _ECharT* __b) { return __b; }
+  static _ECharT const* __range_end(const _ECharT* __b)
+  {
+      using _Iter = const _ECharT*;
+      const _ECharT __sentinal = _ECharT{};
+      _Iter __e = __b;
+      for (; *__e != __sentinal; ++__e)
+          ;
+      return __e;
+  }
+
+  static _ECharT __first_or_null(const _ECharT* __b) { return *__b; }
+};
+
+template <class _Iter, bool _IsIt = __is_input_iterator<_Iter>::value, class = void>
+struct __is_pathable_iter : false_type {};
+
+template <class _Iter>
+struct __is_pathable_iter<_Iter, true,
+        _Void<typename __can_convert_char<typename iterator_traits<_Iter>::value_type>::__char_type>>
+        : __can_convert_char<typename iterator_traits<_Iter>::value_type>
+{
+  using _ECharT = typename iterator_traits<_Iter>::value_type;
+  using _Base = __can_convert_char<_ECharT>;
+
+  static _Iter         __range_begin(_Iter __b) { return __b; }
+  static _NullSentinal __range_end(_Iter)       { return _NullSentinal{}; }
+
+  static _ECharT __first_or_null(_Iter __b) { return *__b; }
+};
+
+template <class _Tp, bool _IsStringT =  __is_pathable_string<_Tp>::value,
+                     bool _IsCharIterT = __is_pathable_char_array<_Tp>::value,
+                     bool _IsIterT = !_IsCharIterT && __is_pathable_iter<_Tp>::value
+         >
+struct __is_pathable : false_type {
+  static_assert(!_IsStringT && !_IsCharIterT && !_IsIterT, "Must all be false");
+};
+
+template <class _Tp>
+struct __is_pathable<_Tp, true, false, false> : __is_pathable_string<_Tp> {};
+
+
+template <class _Tp>
+struct __is_pathable<_Tp, false, true, false> : __is_pathable_char_array<_Tp> {};
+
+
+template <class _Tp>
+struct __is_pathable<_Tp, false, false, true> : __is_pathable_iter<_Tp> {};
+
+
+template <class _ECharT>
+struct _PathCVT {
+    static_assert(__can_convert_char<_ECharT>::value, "Char type not convertible");
+
+    typedef __narrow_to_utf8<sizeof(_ECharT)*__CHAR_BIT__> _Narrower;
+
+    static void __append_range(string& __dest, _ECharT const* __b, _ECharT const* __e)  {
+        _Narrower()(back_inserter(__dest), __b, __e);
+    }
+
+    template <class _Iter>
+    static void __append_range(string& __dest, _Iter __b, _Iter __e) {
+        static_assert(!is_same<_Iter, _ECharT*>::value, "Call const overload");
+        if (__b == __e) return;
+        basic_string<_ECharT> __tmp(__b, __e);
+        _Narrower()(back_inserter(__dest), __tmp.data(),
+                    __tmp.data() + __tmp.length());
+    }
+
+    template <class _Iter>
+    static void __append_range(string& __dest, _Iter __b, _NullSentinal) {
+        static_assert(!is_same<_Iter, _ECharT*>::value, "Call const overload");
+        const _ECharT __sentinal = _ECharT{};
+        if (*__b == __sentinal) return;
+        basic_string<_ECharT> __tmp;
+        for (; *__b != __sentinal; ++__b)
+            __tmp.push_back(*__b);
+        _Narrower()(back_inserter(__dest), __tmp.data(),
+                    __tmp.data() + __tmp.length());
+    }
+
+    template <class _Source>
+    static void __append_source(string& __dest, _Source const& __s)
+    {
+        using _Traits = __is_pathable<_Source>;
+        __append_range(__dest, _Traits::__range_begin(__s), _Traits::__range_end(__s));
+    }
+};
+
+template <>
+struct _PathCVT<char> {
+    template <class _Iter>
+    static void __append_range(string& __dest, _Iter __b, _Iter __e) {
+        for (; __b != __e; ++__b)
+            __dest.push_back(*__b);
+    }
+
+    template <class _Iter>
+    static void __append_range(string& __dest, _Iter __b, _NullSentinal) {
+        const char __sentinal = char{};
+        for (; *__b != __sentinal; ++__b)
+            __dest.push_back(*__b);
+    }
+
+    template <class _Source>
+    static void __append_source(string& __dest, _Source const& __s)
+    {
+        using _Traits = __is_pathable<_Source>;
+        __append_range(__dest, _Traits::__range_begin(__s), _Traits::__range_end(__s));
+    }
+};
+
+
+class _LIBCPP_TYPE_VIS path
+{
+    template <class _SourceOrIter, class _Tp = path&>
+    using _EnableIfPathable = typename
+        enable_if<__is_pathable<_SourceOrIter>::value, _Tp>::type;
+
+    template <class _Tp>
+    using _SourceChar = typename __is_pathable<_Tp>::__char_type;
+
+    template <class _Tp>
+    using _SourceCVT = _PathCVT<_SourceChar<_Tp>>;
+
+public:
+    typedef char value_type;
+    typedef basic_string<value_type> string_type;
+    static _LIBCPP_CONSTEXPR value_type preferred_separator = '/';
+
+    // constructors and destructor
+    _LIBCPP_INLINE_VISIBILITY path() _NOEXCEPT {}
+    _LIBCPP_INLINE_VISIBILITY path(const path& __p)      : __pn_(__p.__pn_) {}
+    _LIBCPP_INLINE_VISIBILITY path(path&& __p) _NOEXCEPT : __pn_(_VSTD::move(__p.__pn_)) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    path(string_type&& __s) _NOEXCEPT : __pn_(_VSTD::move(__s)) {}
+
+    template <
+        class _Source,
+        class = _EnableIfPathable<_Source, void>
+        >
+    path(const _Source& __src) {
+        _SourceCVT<_Source>::__append_source(__pn_, __src);
+    }
+
+    template <class _InputIt>
+    path(_InputIt __first, _InputIt __last) {
+        typedef typename iterator_traits<_InputIt>::value_type _ItVal;
+        _PathCVT<_ItVal>::__append_range(__pn_, __first, __last);
+    }
+
+    // TODO Implement locale conversions.
+    template <class _Source,
+              class = _EnableIfPathable<_Source, void>
+             >
+        path(const _Source& __src, const locale& __loc);
+    template <class _InputIt>
+        path(_InputIt __first, _InputIt _last, const locale& __loc);
+
+    _LIBCPP_INLINE_VISIBILITY
+    ~path() = default;
+
+    // assignments
+    _LIBCPP_INLINE_VISIBILITY
+    path& operator=(const path& __p) {
+        __pn_ = __p.__pn_;
+        return *this;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    path& operator=(path&& __p) _NOEXCEPT {
+        __pn_ = _VSTD::move(__p.__pn_);
+        return *this;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    path& operator=(string_type&& __s) _NOEXCEPT {
+        __pn_ = _VSTD::move(__s);
+        return *this;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    path& assign(string_type&& __s) _NOEXCEPT {
+        __pn_ = _VSTD::move(__s);
+        return *this;
+    }
+
+    template <class _Source>
+    _LIBCPP_INLINE_VISIBILITY
+    _EnableIfPathable<_Source>
+    operator=(const _Source& __src)
+    { return this->assign(__src); }
+
+
+    template <class _Source>
+    _EnableIfPathable<_Source>
+    assign(const _Source& __src) {
+        __pn_.clear();
+        _SourceCVT<_Source>::__append_source(__pn_, __src);
+        return *this;
+    }
+
+    template <class _InputIt>
+    path& assign(_InputIt __first, _InputIt __last) {
+        typedef typename iterator_traits<_InputIt>::value_type _ItVal;
+        __pn_.clear();
+        _PathCVT<_ItVal>::__append_range(__pn_, __first, __last);
+        return *this;
+    }
+
+private:
+    template <class _ECharT>
+    void __append_sep_if_needed(_ECharT __first_or_null) {
+        const _ECharT __null_val = {};
+        bool __append_sep = !empty()                       &&
+                            !__is_separator(__pn_.back())  &&
+                            __first_or_null != __null_val  && // non-empty
+                            !__is_separator(__first_or_null);
+        if (__append_sep)
+            __pn_ += preferred_separator;
+    }
+
+public:
+    // appends
+    path& operator/=(const path& __p) {
+        __append_sep_if_needed(__p.empty() ? char{} : __p.__pn_[0]);
+        __pn_ += __p.native();
+        return *this;
+    }
+
+    template <class _Source>
+    _LIBCPP_INLINE_VISIBILITY
+    _EnableIfPathable<_Source>
+    operator/=(const _Source& __src) {
+        return this->append(__src);
+    }
+
+    template <class _Source>
+    _EnableIfPathable<_Source>
+    append(const _Source& __src) {
+        using _Traits = __is_pathable<_Source>;
+        using _CVT = _PathCVT<_SourceChar<_Source>>;
+        __append_sep_if_needed(_Traits::__first_or_null(__src));
+        _CVT::__append_source(__pn_, __src);
+        return *this;
+    }
+
+    template <class _InputIt>
+    path& append(_InputIt __first, _InputIt __last) {
+        typedef typename iterator_traits<_InputIt>::value_type _ItVal;
+        static_assert(__can_convert_char<_ItVal>::value, "Must convertible");
+        using _CVT = _PathCVT<_ItVal>;
+        if (__first != __last) {
+            __append_sep_if_needed(*__first);
+            _CVT::__append_range(__pn_, __first, __last);
+        }
+        return *this;
+    }
+
+    // concatenation
+    _LIBCPP_INLINE_VISIBILITY
+    path& operator+=(const path& __x) {
+        __pn_ += __x.__pn_;
+        return *this;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    path& operator+=(const string_type& __x) {
+        __pn_ += __x;
+        return *this;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    path& operator+=(const value_type* __x) {
+        __pn_ += __x;
+        return *this;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    path& operator+=(value_type __x) {
+        __pn_ += __x;
+        return *this;
+    }
+
+
+    template <class _ECharT>
+    typename enable_if<__can_convert_char<_ECharT>::value, path&>::type
+    operator+=(_ECharT __x)
+    {
+        basic_string<_ECharT> __tmp;
+        __tmp += __x;
+        _PathCVT<_ECharT>::__append_source(__pn_, __tmp);
+        return *this;
+    }
+
+    template <class _Source>
+    _EnableIfPathable<_Source>
+    operator+=(const _Source& __x) {
+       return this->concat(__x);
+    }
+
+    template <class _Source>
+    _EnableIfPathable<_Source>
+    concat(const _Source& __x) {
+         _SourceCVT<_Source>::__append_source(__pn_, __x);
+        return *this;
+    }
+
+    template <class _InputIt>
+    path& concat(_InputIt __first, _InputIt __last) {
+        typedef typename iterator_traits<_InputIt>::value_type _ItVal;
+        _PathCVT<_ItVal>::__append_range(__pn_, __first, __last);
+        return *this;
+    }
+
+    // modifiers
+    _LIBCPP_INLINE_VISIBILITY
+    void clear() _NOEXCEPT {
+        __pn_.clear();
+    }
+
+    path& make_preferred() { return *this; }
+    path& remove_filename() { return *this = parent_path(); }
+
+    path& replace_filename(const path& __replacement) {
+        remove_filename();
+        return (*this /= __replacement);
+    }
+
+    path& replace_extension(const path& __replacement = path());
+
+    _LIBCPP_INLINE_VISIBILITY
+    void  swap(path& __rhs) _NOEXCEPT {
+        __pn_.swap(__rhs.__pn_);
+    }
+
+    // native format observers
+    _LIBCPP_INLINE_VISIBILITY
+    const string_type& native() const _NOEXCEPT {
+        return __pn_;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    const value_type* c_str() const _NOEXCEPT { return __pn_.c_str(); }
+
+    _LIBCPP_INLINE_VISIBILITY operator string_type() const { return __pn_;  }
+
+    template <class _ECharT, class _Traits = char_traits<_ECharT>,
+              class _Allocator = allocator<_ECharT> >
+    basic_string<_ECharT, _Traits, _Allocator>
+    string(const _Allocator& __a = _Allocator()) const {
+        using _CVT = __widen_from_utf8<sizeof(_ECharT)*__CHAR_BIT__>;
+        using _Str = basic_string<_ECharT, _Traits, _Allocator>;
+        _Str __s(__a);
+        __s.reserve(__pn_.size());
+        _CVT()(back_inserter(__s), __pn_.data(), __pn_.data() + __pn_.size());
+        return __s;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY std::string    string()    const { return __pn_; }
+    _LIBCPP_INLINE_VISIBILITY std::wstring   wstring()   const { return string<wchar_t>(); }
+    _LIBCPP_INLINE_VISIBILITY std::string    u8string()  const { return __pn_; }
+    _LIBCPP_INLINE_VISIBILITY std::u16string u16string() const { return string<char16_t>(); }
+    _LIBCPP_INLINE_VISIBILITY std::u32string u32string() const { return string<char32_t>(); }
+
+    // generic format observers
+    template <class _ECharT, class _Traits = char_traits<_ECharT>,
+              class _Allocator = allocator<_ECharT>
+    >
+    basic_string<_ECharT, _Traits, _Allocator>
+    generic_string(const _Allocator& __a = _Allocator()) const {
+        return string<_ECharT, _Traits, _Allocator>(__a);
+    }
+
+    std::string    generic_string()    const { return __pn_; }
+    std::wstring   generic_wstring()   const { return string<wchar_t>(); }
+    std::string    generic_u8string()  const { return __pn_; }
+    std::u16string generic_u16string() const { return string<char16_t>(); }
+    std::u32string generic_u32string() const { return string<char32_t>(); }
+
+private:
+    _LIBCPP_FUNC_VIS int __compare(const value_type*) const;
+    _LIBCPP_FUNC_VIS string_view __root_name() const;
+    _LIBCPP_FUNC_VIS string_view __root_directory() const;
+    _LIBCPP_FUNC_VIS string_view __relative_path() const;
+    _LIBCPP_FUNC_VIS string_view __parent_path() const;
+    _LIBCPP_FUNC_VIS string_view __filename() const;
+    _LIBCPP_FUNC_VIS string_view __stem() const;
+    _LIBCPP_FUNC_VIS string_view __extension() const;
+
+public:
+    // compare
+    _LIBCPP_INLINE_VISIBILITY int compare(const path& __p) const _NOEXCEPT { return __compare(__p.c_str());}
+    _LIBCPP_INLINE_VISIBILITY int compare(const string_type& __s) const { return __compare(__s.c_str()); }
+    _LIBCPP_INLINE_VISIBILITY int compare(const value_type* __s) const  { return __compare(__s); }
+
+    // decomposition
+    _LIBCPP_INLINE_VISIBILITY path root_name()      const { return  __root_name().to_string(); }
+    _LIBCPP_INLINE_VISIBILITY path root_directory() const { return  __root_directory().to_string(); }
+    _LIBCPP_INLINE_VISIBILITY path root_path()      const { return root_name().append(__root_directory().to_string()); }
+    _LIBCPP_INLINE_VISIBILITY path relative_path()  const { return __relative_path().to_string(); }
+    _LIBCPP_INLINE_VISIBILITY path parent_path()    const { return __parent_path().to_string(); }
+    _LIBCPP_INLINE_VISIBILITY path filename()       const { return __filename().to_string(); }
+    _LIBCPP_INLINE_VISIBILITY path stem()           const { return __stem().to_string();}
+    _LIBCPP_INLINE_VISIBILITY path extension()      const { return __extension().to_string(); }
+
+    // query
+    _LIBCPP_INLINE_VISIBILITY bool empty() const _NOEXCEPT { return __pn_.empty(); }
+
+    _LIBCPP_INLINE_VISIBILITY bool has_root_name()      const { return !__root_name().empty(); }
+    _LIBCPP_INLINE_VISIBILITY bool has_root_directory() const { return !__root_directory().empty(); }
+    _LIBCPP_INLINE_VISIBILITY bool has_root_path()      const { return !(__root_name().empty() && __root_directory().empty()); }
+    _LIBCPP_INLINE_VISIBILITY bool has_relative_path()  const { return !__relative_path().empty(); }
+    _LIBCPP_INLINE_VISIBILITY bool has_parent_path()    const { return !__parent_path().empty(); }
+    _LIBCPP_INLINE_VISIBILITY bool has_filename()       const { return !__filename().empty(); }
+    _LIBCPP_INLINE_VISIBILITY bool has_stem()           const { return !__stem().empty(); }
+    _LIBCPP_INLINE_VISIBILITY bool has_extension()      const { return !__extension().empty(); }
+
+    _LIBCPP_INLINE_VISIBILITY bool is_absolute()        const { return has_root_directory(); }
+    _LIBCPP_INLINE_VISIBILITY bool is_relative()        const { return !is_absolute(); }
+
+    // iterators
+    class _LIBCPP_TYPE_VIS iterator;
+    typedef iterator const_iterator;
+
+    _LIBCPP_FUNC_VIS iterator begin() const;
+    _LIBCPP_FUNC_VIS iterator end() const;
+
+private:
+    inline _LIBCPP_INLINE_VISIBILITY
+    path& __assign_view(string_view const& __s) noexcept { __pn_ = __s.to_string(); return *this; }
+    string_type __pn_;
+};
+
+inline _LIBCPP_ALWAYS_INLINE
+void swap(path& __lhs, path& __rhs) _NOEXCEPT {
+    __lhs.swap(__rhs);
+}
+
+_LIBCPP_FUNC_VIS
+size_t hash_value(const path& __p) _NOEXCEPT;
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool operator==(const path& __lhs, const path& __rhs) _NOEXCEPT
+{ return __lhs.compare(__rhs) == 0; }
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool operator!=(const path& __lhs, const path& __rhs) _NOEXCEPT
+{ return __lhs.compare(__rhs) != 0; }
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool operator<(const path& __lhs, const path& __rhs) _NOEXCEPT
+{ return __lhs.compare(__rhs) < 0; }
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool operator<=(const path& __lhs, const path& __rhs) _NOEXCEPT
+{ return __lhs.compare(__rhs) <= 0; }
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool operator>(const path& __lhs, const path& __rhs) _NOEXCEPT
+{ return __lhs.compare(__rhs) > 0; }
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool operator>=(const path& __lhs, const path& __rhs) _NOEXCEPT
+{ return __lhs.compare(__rhs) >= 0; }
+
+inline _LIBCPP_INLINE_VISIBILITY
+path operator/(const path& __lhs, const path& __rhs) {
+    return path(__lhs) /= __rhs;
+}
+
+template <class _CharT, class _Traits>
+_LIBCPP_INLINE_VISIBILITY
+typename enable_if<is_same<_CharT, char>::value &&
+                   is_same<_Traits, char_traits<char>>::value,
+                   basic_ostream<_CharT, _Traits>&
+>::type
+operator<<(basic_ostream<_CharT, _Traits>& __os, const path& __p) {
+    __os << std::__quoted(__p.native());
+    return __os;
+}
+
+template <class _CharT, class _Traits>
+_LIBCPP_INLINE_VISIBILITY
+typename enable_if<!is_same<_CharT, char>::value ||
+                   !is_same<_Traits, char_traits<char>>::value,
+                   basic_ostream<_CharT, _Traits>&
+>::type
+operator<<(basic_ostream<_CharT, _Traits>& __os, const path& __p) {
+    __os << std::__quoted(__p.string<_CharT, _Traits>());
+    return __os;
+}
+
+template <class _CharT, class _Traits>
+_LIBCPP_INLINE_VISIBILITY
+basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is, path& __p)
+{
+    basic_string<_CharT, _Traits> __tmp;
+    __is >> __quoted(__tmp);
+    __p = __tmp;
+    return __is;
+}
+
+template <class _Source>
+_LIBCPP_INLINE_VISIBILITY
+typename enable_if<__is_pathable<_Source>::value, path>::type
+u8path(const _Source& __s){
+    static_assert(is_same<typename __is_pathable<_Source>::__char_type, char>::value,
+        "u8path(Source const&) requires Source have a character type of type 'char'");
+    return path(__s);
+}
+
+template <class _InputIt>
+_LIBCPP_INLINE_VISIBILITY
+typename enable_if<__is_pathable<_InputIt>::value, path>::type
+u8path(_InputIt __f, _InputIt __l) {
+    static_assert(is_same<typename __is_pathable<_InputIt>::__char_type, char>::value,
+        "u8path(Iter, Iter) requires Iter have a value_type of type 'char'");
+    return path(__f, __l);
+}
+
+class _LIBCPP_TYPE_VIS path::iterator
+{
+public:
+    typedef bidirectional_iterator_tag iterator_category;
+    typedef path                       value_type;
+    typedef std::ptrdiff_t             difference_type;
+    typedef const path*                pointer;
+    typedef const path&                reference;
+public:
+    _LIBCPP_INLINE_VISIBILITY
+    iterator() : __elem_(), __path_ptr_(nullptr), __pos_(0) {}
+
+    iterator(const iterator&) = default;
+    ~iterator() = default;
+
+    iterator& operator=(const iterator&) = default;
+
+    _LIBCPP_INLINE_VISIBILITY
+    reference operator*() const {
+        return __elem_;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    pointer operator->() const {
+        return &__elem_;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    iterator& operator++() {
+        return __increment();
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    iterator operator++(int) {
+        iterator __it(*this);
+        this->operator++();
+        return __it;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    iterator& operator--() {
+        return __decrement();
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    iterator operator--(int) {
+        iterator __it(*this);
+        this->operator--();
+        return __it;
+    }
+
+private:
+    friend class path;
+    friend bool operator==(const iterator&, const iterator&);
+
+    _LIBCPP_FUNC_VIS iterator& __increment();
+    _LIBCPP_FUNC_VIS iterator& __decrement();
+
+    path __elem_;
+    const path* __path_ptr_;
+    size_t __pos_;
+};
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool operator==(const path::iterator& __lhs, const path::iterator& __rhs) {
+    return __lhs.__path_ptr_ == __rhs.__path_ptr_ &&
+           __lhs.__pos_      == __rhs.__pos_;
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool operator!=(const path::iterator& __lhs, const path::iterator& __rhs) {
+    return !(__lhs == __rhs);
+}
+
+class _LIBCPP_EXCEPTION_ABI filesystem_error : public system_error
+{
+public:
+    _LIBCPP_INLINE_VISIBILITY
+    filesystem_error(const string& __what, error_code __ec)
+        : system_error(__ec, __what),
+          __paths_(make_shared<_Storage>(path(), path()))
+    {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    filesystem_error(const string& __what, const path& __p1, error_code __ec)
+        : system_error(__ec, __what),
+        __paths_(make_shared<_Storage>(__p1, path()))
+    {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    filesystem_error(const string& __what, const path& __p1, const path& __p2,
+                     error_code __ec)
+        : system_error(__ec, __what),
+          __paths_(make_shared<_Storage>(__p1, __p2))
+    {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    const path& path1() const _NOEXCEPT {
+        return __paths_->first;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    const path& path2() const _NOEXCEPT {
+        return __paths_->second;
+    }
+
+    _LIBCPP_FUNC_VIS
+    ~filesystem_error() override; // key function
+
+    // TODO(ericwf): Create a custom error message.
+    //const char* what() const _NOEXCEPT;
+
+private:
+    typedef pair<path, path> _Storage;
+    shared_ptr<_Storage> __paths_;
+};
+
+// operational functions
+
+_LIBCPP_FUNC_VIS
+path __canonical(const path&, const path&, error_code *__ec=nullptr);
+_LIBCPP_FUNC_VIS
+void __copy(const path& __from, const path& __to, copy_options __opt,
+        error_code *__ec=nullptr);
+_LIBCPP_FUNC_VIS
+bool __copy_file(const path& __from, const path& __to, copy_options __opt,
+        error_code *__ec=nullptr);
+_LIBCPP_FUNC_VIS
+void __copy_symlink(const path& __existing_symlink, const path& __new_symlink,
+        error_code *__ec=nullptr);
+_LIBCPP_FUNC_VIS
+bool __create_directories(const path& p, error_code *ec=nullptr);
+_LIBCPP_FUNC_VIS
+bool __create_directory(const path& p, error_code *ec=nullptr);
+_LIBCPP_FUNC_VIS
+bool __create_directory(const path& p, const path & attributes,
+        error_code *ec=nullptr);
+_LIBCPP_FUNC_VIS
+void __create_directory_symlink(const path& __to, const path& __new_symlink,
+        error_code *__ec=nullptr);
+_LIBCPP_FUNC_VIS
+void __create_hard_link(const path& __to, const path& __new_hard_link,
+        error_code *__ec=nullptr);
+_LIBCPP_FUNC_VIS
+void __create_symlink(const path& __to, const path& __new_symlink,
+        error_code *__ec=nullptr);
+_LIBCPP_FUNC_VIS
+path __current_path(error_code *__ec=nullptr);
+_LIBCPP_FUNC_VIS
+void __current_path(const path&, error_code *__ec=nullptr);
+_LIBCPP_FUNC_VIS
+bool __equivalent(const path&, const path&, error_code *__ec=nullptr);
+_LIBCPP_FUNC_VIS
+uintmax_t __file_size(const path&, error_code *__ec=nullptr);
+_LIBCPP_FUNC_VIS
+uintmax_t __hard_link_count(const path&, error_code *__ec=nullptr);
+_LIBCPP_FUNC_VIS
+bool __fs_is_empty(const path& p, error_code *ec=nullptr);
+_LIBCPP_FUNC_VIS
+file_time_type __last_write_time(const path& p, error_code *ec=nullptr);
+_LIBCPP_FUNC_VIS
+void __last_write_time(const path& p, file_time_type new_time,
+        error_code *ec=nullptr);
+_LIBCPP_FUNC_VIS
+void __permissions(const path& p, perms prms, error_code *ec=nullptr);
+_LIBCPP_FUNC_VIS
+path __read_symlink(const path& p, error_code *ec=nullptr);
+_LIBCPP_FUNC_VIS
+bool __remove(const path& p, error_code *ec=nullptr);
+_LIBCPP_FUNC_VIS
+uintmax_t __remove_all(const path& p, error_code *ec=nullptr);
+_LIBCPP_FUNC_VIS
+void __rename(const path& from, const path& to, error_code *ec=nullptr);
+_LIBCPP_FUNC_VIS
+void __resize_file(const path& p, uintmax_t size, error_code *ec=nullptr);
+_LIBCPP_FUNC_VIS
+space_info __space(const path&, error_code *__ec=nullptr);
+_LIBCPP_FUNC_VIS
+file_status __status(const path&, error_code *__ec=nullptr);
+_LIBCPP_FUNC_VIS
+file_status __symlink_status(const path&, error_code *__ec=nullptr);
+_LIBCPP_FUNC_VIS
+path __system_complete(const path&, error_code *__ec=nullptr);
+_LIBCPP_FUNC_VIS
+path __temp_directory_path(error_code *__ec=nullptr);
+
+inline _LIBCPP_INLINE_VISIBILITY
+path current_path() {
+    return __current_path();
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+path current_path(error_code& __ec) {
+    return __current_path(&__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void current_path(const path& __p) {
+    __current_path(__p);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void current_path(const path& __p, error_code& __ec) _NOEXCEPT {
+    __current_path(__p, &__ec);
+}
+
+_LIBCPP_FUNC_VIS
+path absolute(const path&, const path& __p2 = current_path());
+
+inline _LIBCPP_INLINE_VISIBILITY
+path canonical(const path& __p, const path& __base = current_path()) {
+    return __canonical(__p, __base);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+path canonical(const path& __p, error_code& __ec) {
+    path __base = __current_path(&__ec);
+    if (__ec) return {};
+    return __canonical(__p, __base, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+path canonical(const path& __p, const path& __base, error_code& __ec) {
+    return __canonical(__p, __base, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void copy(const path& __from, const path& __to) {
+    __copy(__from, __to, copy_options::none);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void copy(const path& __from, const path& __to, error_code& __ec) _NOEXCEPT {
+    __copy(__from, __to, copy_options::none, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void copy(const path& __from, const path& __to, copy_options __opt) {
+    __copy(__from, __to, __opt);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void copy(const path& __from, const path& __to,
+          copy_options __opt, error_code& __ec) _NOEXCEPT {
+    __copy(__from, __to, __opt, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool copy_file(const path& __from, const path& __to) {
+    return __copy_file(__from, __to, copy_options::none);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool copy_file(const path& __from, const path& __to, error_code& __ec) _NOEXCEPT {
+    return __copy_file(__from, __to, copy_options::none, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool copy_file(const path& __from, const path& __to, copy_options __opt) {
+    return __copy_file(__from, __to, __opt);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool copy_file(const path& __from, const path& __to,
+               copy_options __opt, error_code& __ec) _NOEXCEPT {
+    return __copy_file(__from, __to, __opt, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void copy_symlink(const path& __existing, const path& __new) {
+    __copy_symlink(__existing, __new);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void copy_symlink(const path& __ext, const path& __new, error_code& __ec) _NOEXCEPT {
+    __copy_symlink(__ext, __new, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool create_directories(const path& __p) {
+    return __create_directories(__p);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool create_directories(const path& __p, error_code& __ec) _NOEXCEPT {
+    return __create_directories(__p, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool create_directory(const path& __p) {
+    return __create_directory(__p);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool create_directory(const path& __p, error_code& __ec) _NOEXCEPT {
+    return __create_directory(__p, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool create_directory(const path& __p, const path& __attrs) {
+    return __create_directory(__p, __attrs);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool create_directory(const path& __p, const path& __attrs, error_code& __ec) _NOEXCEPT {
+    return __create_directory(__p, __attrs, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void create_directory_symlink(const path& __to, const path& __new) {
+    __create_directory_symlink(__to, __new);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void create_directory_symlink(const path& __to, const path& __new,
+                              error_code& __ec) _NOEXCEPT {
+    __create_directory_symlink(__to, __new, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void create_hard_link(const path& __to, const path& __new) {
+    __create_hard_link(__to, __new);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void create_hard_link(const path& __to, const path& __new, error_code& __ec) _NOEXCEPT {
+    __create_hard_link(__to, __new, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void create_symlink(const path& __to, const path& __new) {
+    __create_symlink(__to, __new);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void create_symlink(const path& __to, const path& __new, error_code& __ec) _NOEXCEPT {
+    return __create_symlink(__to, __new, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool status_known(file_status __s) _NOEXCEPT {
+    return __s.type() != file_type::none;
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool exists(file_status __s) _NOEXCEPT {
+    return status_known(__s) && __s.type() != file_type::not_found;
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool exists(const path& __p) {
+    return exists(__status(__p));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool exists(const path& __p, error_code& __ec) _NOEXCEPT {
+    auto __s = __status(__p, &__ec);
+    if (status_known(__s)) __ec.clear();
+    return exists(__s);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool equivalent(const path& __p1, const path& __p2) {
+    return __equivalent(__p1, __p2);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool equivalent(const path& __p1, const path& __p2, error_code& __ec) _NOEXCEPT {
+    return __equivalent(__p1, __p2, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+uintmax_t file_size(const path& __p) {
+    return __file_size(__p);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+uintmax_t file_size(const path& __p, error_code& __ec) _NOEXCEPT {
+    return __file_size(__p, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+uintmax_t hard_link_count(const path& __p) {
+    return __hard_link_count(__p);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+uintmax_t hard_link_count(const path& __p, error_code& __ec) _NOEXCEPT {
+    return __hard_link_count(__p, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_block_file(file_status __s) _NOEXCEPT {
+    return __s.type() == file_type::block;
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_block_file(const path& __p) {
+    return is_block_file(__status(__p));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_block_file(const path& __p, error_code& __ec) _NOEXCEPT {
+    return is_block_file(__status(__p, &__ec));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_character_file(file_status __s) _NOEXCEPT {
+    return __s.type() == file_type::character;
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_character_file(const path& __p) {
+    return is_character_file(__status(__p));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_character_file(const path& __p, error_code& __ec) _NOEXCEPT {
+    return is_character_file(__status(__p, &__ec));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_directory(file_status __s) _NOEXCEPT {
+    return __s.type() == file_type::directory;
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_directory(const path& __p) {
+    return is_directory(__status(__p));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_directory(const path& __p, error_code& __ec) _NOEXCEPT {
+    return is_directory(__status(__p, &__ec));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_empty(const path& __p) {
+    return __fs_is_empty(__p);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_empty(const path& __p, error_code& __ec) _NOEXCEPT {
+    return __fs_is_empty(__p, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_fifo(file_status __s) _NOEXCEPT {
+    return __s.type() == file_type::fifo;
+}
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_fifo(const path& __p) {
+    return is_fifo(__status(__p));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_fifo(const path& __p, error_code& __ec) _NOEXCEPT {
+    return is_fifo(__status(__p, &__ec));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_regular_file(file_status __s) _NOEXCEPT {
+    return __s.type() == file_type::regular;
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_regular_file(const path& __p) {
+    return is_regular_file(__status(__p));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_regular_file(const path& __p, error_code& __ec) _NOEXCEPT {
+    return is_regular_file(__status(__p, &__ec));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_socket(file_status __s) _NOEXCEPT {
+    return __s.type() == file_type::socket;
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_socket(const path& __p) {
+    return is_socket(__status(__p));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_socket(const path& __p, error_code& __ec) _NOEXCEPT {
+    return is_socket(__status(__p, &__ec));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_symlink(file_status __s) _NOEXCEPT {
+    return __s.type() == file_type::symlink;
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_symlink(const path& __p) {
+    return is_symlink(__symlink_status(__p));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_symlink(const path& __p, error_code& __ec) _NOEXCEPT {
+    return is_symlink(__symlink_status(__p, &__ec));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_other(file_status __s) _NOEXCEPT {
+    return exists(__s)
+        && !is_regular_file(__s) && !is_directory(__s) && !is_symlink(__s);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_other(const path& __p) {
+    return is_other(__status(__p));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_other(const path& __p, error_code& __ec) _NOEXCEPT {
+    return is_other(__status(__p, &__ec));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+file_time_type last_write_time(const path& __p) {
+    return __last_write_time(__p);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+file_time_type last_write_time(const path& __p, error_code& __ec) _NOEXCEPT {
+    return __last_write_time(__p, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void last_write_time(const path& __p, file_time_type __t) {
+    __last_write_time(__p, __t);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void last_write_time(const path& __p, file_time_type __t, error_code& __ec) _NOEXCEPT {
+    __last_write_time(__p, __t, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void permissions(const path& __p, perms __prms) {
+    __permissions(__p, __prms);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void permissions(const path& __p, perms __prms, error_code& __ec)  {
+    __permissions(__p, __prms, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+path read_symlink(const path& __p) {
+    return __read_symlink(__p);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+path read_symlink(const path& __p, error_code& __ec) {
+    return __read_symlink(__p, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool remove(const path& __p) {
+    return __remove(__p);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool remove(const path& __p, error_code& __ec) _NOEXCEPT {
+    return __remove(__p, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+uintmax_t remove_all(const path& __p) {
+    return __remove_all(__p);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+uintmax_t remove_all(const path& __p, error_code& __ec) _NOEXCEPT {
+    return __remove_all(__p, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void rename(const path& __from, const path& __to) {
+    return __rename(__from, __to);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void rename(const path& __from, const path& __to, error_code& __ec) _NOEXCEPT {
+    return __rename(__from, __to, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void resize_file(const path& __p, uintmax_t __ns) {
+    return __resize_file(__p, __ns);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void resize_file(const path& __p, uintmax_t __ns, error_code& __ec) _NOEXCEPT {
+    return __resize_file(__p, __ns, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+space_info space(const path& __p) {
+    return __space(__p);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+space_info space(const path& __p, error_code& __ec) _NOEXCEPT {
+    return __space(__p, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+file_status status(const path& __p) {
+    return __status(__p);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+file_status status(const path& __p, error_code& __ec) _NOEXCEPT {
+    return __status(__p, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+file_status symlink_status(const path& __p) {
+    return __symlink_status(__p);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+file_status symlink_status(const path& __p, error_code& __ec) _NOEXCEPT {
+    return __symlink_status(__p, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+path system_complete(const path& __p) {
+    return __system_complete(__p);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+path system_complete(const path& __p, error_code& __ec) {
+    return __system_complete(__p, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+path temp_directory_path() {
+    return __temp_directory_path();
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+path temp_directory_path(error_code& __ec) {
+    return __temp_directory_path(&__ec);
+}
+
+
+class directory_entry
+{
+    typedef _VSTD_FS::path _Path;
+
+public:
+    // constructors and destructors
+    directory_entry() _NOEXCEPT = default;
+    directory_entry(directory_entry const&) = default;
+    directory_entry(directory_entry&&) _NOEXCEPT = default;
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit directory_entry(_Path const& __p) : __p_(__p) {}
+
+    ~directory_entry() {}
+
+    directory_entry& operator=(directory_entry const&) = default;
+    directory_entry& operator=(directory_entry&&) _NOEXCEPT = default;
+
+    _LIBCPP_INLINE_VISIBILITY
+    void assign(_Path const& __p) {
+        __p_ = __p;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    void replace_filename(_Path const& __p) {
+        __p_ = __p_.parent_path() / __p;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    _Path const& path() const _NOEXCEPT {
+        return __p_;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    operator const _Path&() const _NOEXCEPT {
+        return __p_;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    file_status status() const {
+        return _VSTD_FS::status(__p_);
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    file_status status(error_code& __ec) const _NOEXCEPT {
+        return _VSTD_FS::status(__p_, __ec);
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    file_status symlink_status() const {
+        return _VSTD_FS::symlink_status(__p_);
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    file_status symlink_status(error_code& __ec) const _NOEXCEPT {
+        return _VSTD_FS::symlink_status(__p_, __ec);
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    bool operator< (directory_entry const& __rhs) const _NOEXCEPT {
+        return __p_ < __rhs.__p_;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    bool operator==(directory_entry const& __rhs) const _NOEXCEPT {
+        return __p_ == __rhs.__p_;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    bool operator!=(directory_entry const& __rhs) const _NOEXCEPT {
+        return __p_ != __rhs.__p_;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    bool operator<=(directory_entry const& __rhs) const _NOEXCEPT {
+        return __p_ <= __rhs.__p_;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    bool operator> (directory_entry const& __rhs) const _NOEXCEPT {
+        return __p_ > __rhs.__p_;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    bool operator>=(directory_entry const& __rhs) const _NOEXCEPT {
+        return __p_ >= __rhs.__p_;
+    }
+private:
+    _Path __p_;
+};
+
+
+class directory_iterator;
+class recursive_directory_iterator;
+class __dir_stream;
+
+class __dir_element_proxy {
+public:
+
+    inline _LIBCPP_INLINE_VISIBILITY
+    directory_entry operator*() { return _VSTD::move(__elem_); }
+
+private:
+    friend class directory_iterator;
+    friend class recursive_directory_iterator;
+    explicit __dir_element_proxy(directory_entry const& __e) : __elem_(__e) {}
+    __dir_element_proxy(__dir_element_proxy&& __o) : __elem_(_VSTD::move(__o.__elem_)) {}
+    directory_entry __elem_;
+};
+
+class directory_iterator
+{
+public:
+    typedef directory_entry value_type;
+    typedef ptrdiff_t difference_type;
+    typedef value_type const* pointer;
+    typedef value_type const& reference;
+    typedef input_iterator_tag iterator_category;
+
+public:
+    //ctor & dtor
+    directory_iterator() _NOEXCEPT
+    { }
+
+    explicit directory_iterator(const path& __p)
+        : directory_iterator(__p, nullptr)
+    { }
+
+    directory_iterator(const path& __p, directory_options __opts)
+        : directory_iterator(__p, nullptr, __opts)
+    { }
+
+    directory_iterator(const path& __p, error_code& __ec) _NOEXCEPT
+        : directory_iterator(__p, &__ec)
+    { }
+
+    directory_iterator(const path& __p, directory_options __opts,
+                       error_code& __ec) _NOEXCEPT
+        : directory_iterator(__p, &__ec, __opts)
+    { }
+
+    directory_iterator(const directory_iterator&) = default;
+    directory_iterator(directory_iterator&&) = default;
+    directory_iterator& operator=(const directory_iterator&) = default;
+
+    directory_iterator& operator=(directory_iterator&& __o) _NOEXCEPT {
+        // non-default implementation provided to support self-move assign.
+        if (this != &__o) {
+            __imp_ = _VSTD::move(__o.__imp_);
+        }
+        return *this;
+    }
+
+    ~directory_iterator() = default;
+
+    const directory_entry& operator*() const {
+        _LIBCPP_ASSERT(__imp_, "The end iterator cannot be dereferenced");
+        return __deref();
+    }
+
+    const directory_entry* operator->() const
+    { return &**this; }
+
+    directory_iterator& operator++()
+    { return __increment(); }
+
+    __dir_element_proxy operator++(int) {
+        __dir_element_proxy __p(**this);
+        __increment();
+        return __p;
+    }
+
+    directory_iterator& increment(error_code& __ec) _NOEXCEPT
+    { return __increment(&__ec); }
+
+private:
+    friend bool operator==(const directory_iterator& __lhs,
+                           const directory_iterator& __rhs) _NOEXCEPT;
+
+    // construct the dir_stream
+    _LIBCPP_FUNC_VIS
+    directory_iterator(const path&, error_code *, directory_options = directory_options::none);
+    _LIBCPP_FUNC_VIS
+    directory_iterator& __increment(error_code * __ec = nullptr);
+    _LIBCPP_FUNC_VIS
+    const directory_entry& __deref() const;
+
+private:
+    shared_ptr<__dir_stream> __imp_;
+};
+
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool operator==(const directory_iterator& __lhs,
+                const directory_iterator& __rhs) _NOEXCEPT {
+    return __lhs.__imp_ == __rhs.__imp_;
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool operator!=(const directory_iterator& __lhs,
+                const directory_iterator& __rhs) _NOEXCEPT {
+    return !(__lhs == __rhs);
+}
+
+// enable directory_iterator range-based for statements
+inline _LIBCPP_INLINE_VISIBILITY
+directory_iterator begin(directory_iterator __iter) _NOEXCEPT {
+    return __iter;
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+directory_iterator end(const directory_iterator&) _NOEXCEPT {
+    return directory_iterator();
+}
+
+class recursive_directory_iterator {
+public:
+    using value_type = directory_entry;
+    using difference_type = std::ptrdiff_t;
+    using pointer = directory_entry const *;
+    using reference = directory_entry const &;
+    using iterator_category = std::input_iterator_tag;
+
+public:
+    // constructors and destructor
+    _LIBCPP_INLINE_VISIBILITY
+    recursive_directory_iterator()  _NOEXCEPT
+        : __rec_(false)
+    {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit recursive_directory_iterator(const path& __p,
+                directory_options __xoptions = directory_options::none)
+        : recursive_directory_iterator(__p, __xoptions,  nullptr)
+    { }
+
+    _LIBCPP_INLINE_VISIBILITY
+    recursive_directory_iterator(const path& __p,
+        directory_options __xoptions, error_code& __ec) _NOEXCEPT
+        : recursive_directory_iterator(__p, __xoptions, &__ec)
+    { }
+
+    _LIBCPP_INLINE_VISIBILITY
+    recursive_directory_iterator(const path& __p, error_code& __ec) _NOEXCEPT
+        : recursive_directory_iterator(__p, directory_options::none,  &__ec)
+    { }
+
+    recursive_directory_iterator(const recursive_directory_iterator&) = default;
+    recursive_directory_iterator(recursive_directory_iterator&&) = default;
+
+    recursive_directory_iterator &
+    operator=(const recursive_directory_iterator&) = default;
+
+    _LIBCPP_INLINE_VISIBILITY
+    recursive_directory_iterator &
+    operator=(recursive_directory_iterator&& __o) noexcept {
+        // non-default implementation provided to support self-move assign.
+        if (this != &__o) {
+            __imp_ = _VSTD::move(__o.__imp_);
+            __rec_ = __o.__rec_;
+        }
+        return *this;
+    }
+
+    ~recursive_directory_iterator() = default;
+
+    _LIBCPP_INLINE_VISIBILITY
+    const directory_entry& operator*() const
+    { return __deref(); }
+
+    _LIBCPP_INLINE_VISIBILITY
+    const directory_entry* operator->() const
+    { return &__deref(); }
+
+    recursive_directory_iterator& operator++()
+    { return __increment(); }
+
+    _LIBCPP_INLINE_VISIBILITY
+    __dir_element_proxy operator++(int) {
+        __dir_element_proxy __p(**this);
+        __increment();
+        return __p;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    recursive_directory_iterator& increment(error_code& __ec) _NOEXCEPT
+    { return __increment(&__ec); }
+
+    _LIBCPP_FUNC_VIS directory_options options() const;
+    _LIBCPP_FUNC_VIS int  depth() const;
+
+    _LIBCPP_INLINE_VISIBILITY
+    void pop() { __pop(); }
+
+    _LIBCPP_INLINE_VISIBILITY
+    void pop(error_code& __ec)
+    { __pop(&__ec); }
+
+    _LIBCPP_INLINE_VISIBILITY
+    bool recursion_pending() const
+    { return __rec_; }
+
+    _LIBCPP_INLINE_VISIBILITY
+    void disable_recursion_pending()
+    { __rec_ = false; }
+
+private:
+    recursive_directory_iterator(const path& __p, directory_options __opt,
+                                 error_code *__ec);
+
+    _LIBCPP_FUNC_VIS
+    const directory_entry& __deref() const;
+
+    _LIBCPP_FUNC_VIS
+    bool __try_recursion(error_code* __ec);
+
+    _LIBCPP_FUNC_VIS
+    void __advance(error_code* __ec=nullptr);
+
+    _LIBCPP_FUNC_VIS
+    recursive_directory_iterator& __increment(error_code *__ec=nullptr);
+
+    _LIBCPP_FUNC_VIS
+    void __pop(error_code* __ec=nullptr);
+
+    friend bool operator==(const recursive_directory_iterator&,
+                           const recursive_directory_iterator&) _NOEXCEPT;
+
+    struct __shared_imp;
+    shared_ptr<__shared_imp> __imp_;
+    bool __rec_;
+};                                     // class recursive_directory_iterator
+
+
+_LIBCPP_INLINE_VISIBILITY
+inline bool operator==(const recursive_directory_iterator& __lhs,
+                        const recursive_directory_iterator& __rhs) _NOEXCEPT
+{
+    return __lhs.__imp_ == __rhs.__imp_;
+}
+
+_LIBCPP_INLINE_VISIBILITY
+inline bool operator!=(const recursive_directory_iterator& __lhs,
+                        const recursive_directory_iterator& __rhs) _NOEXCEPT
+{
+    return !(__lhs == __rhs);
+}
+// enable recursive_directory_iterator range-based for statements
+inline _LIBCPP_INLINE_VISIBILITY
+recursive_directory_iterator begin(recursive_directory_iterator __iter) _NOEXCEPT {
+    return __iter;
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+recursive_directory_iterator end(const recursive_directory_iterator&) _NOEXCEPT {
+    return recursive_directory_iterator();
+}
+
+_LIBCPP_END_NAMESPACE_EXPERIMENTAL_FILESYSTEM
+
+#endif // _LIBCPP_EXPERIMENTAL_FILESYSTEM
diff --git a/include/experimental/forward_list b/include/experimental/forward_list
new file mode 100644
index 000000000000..55e195f446f5
--- /dev/null
+++ b/include/experimental/forward_list
@@ -0,0 +1,47 @@
+// -*- C++ -*-
+//===--------------------------- forward_list -----------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPERIMENTAL_FORWARD_LIST
+#define _LIBCPP_EXPERIMENTAL_FORWARD_LIST
+/*
+    experimental/forward_list synopsis
+
+// C++1z
+namespace std {
+namespace experimental {
+inline namespace fundamentals_v1 {
+namespace pmr {
+
+  template <class T>
+  using forward_list = std::forward_list<T,polymorphic_allocator<T>>;
+
+} // namespace pmr
+} // namespace fundamentals_v1
+} // namespace experimental
+} // namespace std
+
+ */
+
+#include <experimental/__config>
+#include <forward_list>
+#include <experimental/memory_resource>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
+
+template <class _ValueT>
+using forward_list = _VSTD::forward_list<_ValueT, polymorphic_allocator<_ValueT>>;
+
+_LIBCPP_END_NAMESPACE_LFTS_PMR
+
+#endif /* _LIBCPP_EXPERIMENTAL_FORWARD_LIST */
diff --git a/include/experimental/functional b/include/experimental/functional
index c7a78695b809..75fc8e99f352 100644
--- a/include/experimental/functional
+++ b/include/experimental/functional
@@ -119,9 +119,12 @@ public:
 
     template <typename _ForwardIterator2>
     _LIBCPP_INLINE_VISIBILITY
-    _ForwardIterator2 operator () (_ForwardIterator2 __f, _ForwardIterator2 __l) const
+    pair<_ForwardIterator2, _ForwardIterator2>
+    operator () (_ForwardIterator2 __f, _ForwardIterator2 __l) const
     {
-        return _VSTD::search(__f, __l, __first_, __last_, __pred_);
+        return _VSTD::__search(__f, __l, __first_, __last_, __pred_,
+            typename _VSTD::iterator_traits<_ForwardIterator>::iterator_category(),
+            typename _VSTD::iterator_traits<_ForwardIterator2>::iterator_category());
     }
 
 private:
@@ -233,7 +236,7 @@ public:
         }
         
     template <typename _RandomAccessIterator2>
-    _RandomAccessIterator2 
+    pair<_RandomAccessIterator2, _RandomAccessIterator2>
     operator ()(_RandomAccessIterator2 __f, _RandomAccessIterator2 __l) const
     {
         static_assert ( std::is_same<
@@ -242,12 +245,12 @@ public:
                     >::value,
                 "Corpus and Pattern iterators must point to the same type" );
 
-        if (__f      == __l )    return __l; // empty corpus
-        if (__first_ == __last_) return __f; // empty pattern
+        if (__f      == __l )    return make_pair(__l, __l); // empty corpus
+        if (__first_ == __last_) return make_pair(__f, __f); // empty pattern
 
     //  If the pattern is larger than the corpus, we can't find it!
         if ( __pattern_length_ > _VSTD::distance (__f, __l)) 
-            return __l;
+            return make_pair(__l, __l);
 
     //  Do the search 
         return this->__search(__f, __l);
@@ -262,7 +265,8 @@ public: // TODO private:
     shared_ptr<vector<difference_type>>  __suffix_;
 
     template <typename _RandomAccessIterator2>
-    _RandomAccessIterator2 __search(_RandomAccessIterator2 __f, _RandomAccessIterator2 __l) const
+    pair<_RandomAccessIterator2, _RandomAccessIterator2>
+    __search(_RandomAccessIterator2 __f, _RandomAccessIterator2 __l) const
     {
         _RandomAccessIterator2 __cur = __f;
         const _RandomAccessIterator2 __last = __l - __pattern_length_;
@@ -278,7 +282,7 @@ public: // TODO private:
                 __j--;
             //  We matched - we're done!
                 if ( __j == 0 )
-                    return __cur;
+                    return make_pair(__cur, __cur + __pattern_length_);
                 }
             
         //  Since we didn't match, figure out how far to skip forward
@@ -290,7 +294,7 @@ public: // TODO private:
                 __cur += __suffix[ __j ];
         }
     
-        return __l;     // We didn't find anything
+        return make_pair(__l, __l);     // We didn't find anything
     }
 
 
@@ -384,8 +388,8 @@ public:
             }
         }
             
-     template <typename _RandomAccessIterator2>
-    _RandomAccessIterator2 
+    template <typename _RandomAccessIterator2>
+    pair<_RandomAccessIterator2, _RandomAccessIterator2>
     operator ()(_RandomAccessIterator2 __f, _RandomAccessIterator2 __l) const
     {
         static_assert ( std::is_same<
@@ -394,12 +398,12 @@ public:
                     >::value,
                 "Corpus and Pattern iterators must point to the same type" );
 
-        if (__f      == __l )    return __l; // empty corpus
-        if (__first_ == __last_) return __f; // empty pattern
+        if (__f      == __l )    return make_pair(__l, __l); // empty corpus
+        if (__first_ == __last_) return make_pair(__f, __f); // empty pattern
 
     //  If the pattern is larger than the corpus, we can't find it!
         if ( __pattern_length_ > _VSTD::distance (__f, __l)) 
-            return __l;
+            return make_pair(__l, __l);
 
     //  Do the search 
         return this->__search(__f, __l);
@@ -413,7 +417,8 @@ private:
     shared_ptr<skip_table_type> __skip_;
 
     template <typename _RandomAccessIterator2>
-    _RandomAccessIterator2 __search ( _RandomAccessIterator2 __f, _RandomAccessIterator2 __l ) const {
+    pair<_RandomAccessIterator2, _RandomAccessIterator2>
+    __search ( _RandomAccessIterator2 __f, _RandomAccessIterator2 __l ) const {
         _RandomAccessIterator2 __cur = __f;
         const _RandomAccessIterator2 __last = __l - __pattern_length_;
         const skip_table_type & __skip = *__skip_.get();
@@ -427,12 +432,12 @@ private:
                 __j--;
             //  We matched - we're done!
                 if ( __j == 0 )
-                    return __cur;
+                    return make_pair(__cur, __cur + __pattern_length_);
             }
             __cur += __skip[__cur[__pattern_length_-1]];
         }
         
-        return __l;
+        return make_pair(__l, __l);
     }
 };
 
diff --git a/include/experimental/iterator b/include/experimental/iterator
new file mode 100644
index 000000000000..da593febe2b4
--- /dev/null
+++ b/include/experimental/iterator
@@ -0,0 +1,114 @@
+// -*- C++ -*-
+//===----------------------------- iterator -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPERIMENTAL_ITERATOR
+#define _LIBCPP_EXPERIMENTAL_ITERATOR
+
+/*
+namespace std {
+  namespace experimental {
+    inline namespace fundamentals_v2 {
+
+    template <class DelimT, class charT = char, class traits = char_traits<charT>>
+        class ostream_joiner {
+        public:
+         typedef charT                        char_type;
+         typedef traits                       traits_type;
+         typedef basic_ostream<charT, traits> ostream_type;
+         typedef output_iterator_tag          iterator_category;
+         typedef void                         value_type;
+         typedef void                         difference_type;
+         typedef void                         pointer;
+         typedef void                         reference;
+      
+         ostream_joiner(ostream_type& s, const DelimT& delimiter);
+         ostream_joiner(ostream_type& s, DelimT&& delimiter);
+
+         template<typename T>  
+         ostream_joiner& operator=(const T& value);
+
+         ostream_joiner& operator*() noexcept;
+         ostream_joiner& operator++() noexcept;
+         ostream_joiner& operator++(int) noexcept;
+   private:
+      ostream_type* out_stream;   // exposition only 
+      DelimT delim;               // exposition only 
+      bool first_element;         // exposition only
+   };
+
+  template <class charT, class traits, class DelimT>
+    ostream_joiner<decay_t<DelimT>, charT, traits>
+    make_ostream_joiner(basic_ostream<charT, traits>& os, DelimT&& delimiter);
+
+    } // inline namespace fundamentals_v2
+  } // namespace experimental
+} // namespace std
+
+*/
+
+#include <experimental/__config>
+
+#if _LIBCPP_STD_VER > 11
+
+#include <iterator>
+
+_LIBCPP_BEGIN_NAMESPACE_LFTS
+
+template <class _Delim, class _CharT = char, class _Traits = char_traits<_CharT>>
+class ostream_joiner {
+public:
+
+    typedef _CharT                               char_type;
+    typedef _Traits                              traits_type;
+    typedef basic_ostream<char_type,traits_type> ostream_type;
+    typedef output_iterator_tag                  iterator_category;
+    typedef void                                 value_type;
+    typedef void                                 difference_type;
+    typedef void                                 pointer;
+    typedef void                                 reference;
+
+    ostream_joiner(ostream_type& __os, _Delim&& __d)
+        : __out(_VSTD::addressof(__os)), __delim(_VSTD::move(__d)), __first(true) {}
+        
+    ostream_joiner(ostream_type& __os, const _Delim& __d)
+        : __out(_VSTD::addressof(__os)), __delim(__d), __first(true) {}
+    
+
+    template<typename _Tp>
+    ostream_joiner& operator=(const _Tp& __v)
+    {
+        if (!__first)
+            *__out << __delim;
+        __first = false;
+        *__out << __v;
+        return *this;
+    }
+
+    ostream_joiner& operator*()     _NOEXCEPT { return *this; }
+    ostream_joiner& operator++()    _NOEXCEPT { return *this; }
+    ostream_joiner& operator++(int) _NOEXCEPT { return *this; }
+
+private:
+    ostream_type*   __out;
+    _Delim          __delim;
+    bool            __first;
+};
+
+
+template <class _CharT, class _Traits, class _Delim>
+ostream_joiner<typename decay<_Delim>::type, _CharT, _Traits>
+make_ostream_joiner(basic_ostream<_CharT, _Traits>& __os, _Delim && __d)
+{ return ostream_joiner<typename decay<_Delim>::type, _CharT, _Traits>(__os, _VSTD::forward<_Delim>(__d)); }
+
+_LIBCPP_END_NAMESPACE_LFTS
+
+#endif /* _LIBCPP_STD_VER > 11 */
+
+#endif // _LIBCPP_EXPERIMENTAL_ITERATOR
diff --git a/include/experimental/list b/include/experimental/list
new file mode 100644
index 000000000000..1678ee3e93cb
--- /dev/null
+++ b/include/experimental/list
@@ -0,0 +1,47 @@
+// -*- C++ -*-
+//===--------------------------- list ------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPERIMENTAL_LIST
+#define _LIBCPP_EXPERIMENTAL_LIST
+/*
+    experimental/list synopsis
+
+// C++1z
+namespace std {
+namespace experimental {
+inline namespace fundamentals_v1 {
+namespace pmr {
+
+  template <class T>
+  using list = std::list<T,polymorphic_allocator<T>>;
+
+} // namespace pmr
+} // namespace fundamentals_v1
+} // namespace experimental
+} // namespace std
+
+ */
+
+#include <experimental/__config>
+#include <list>
+#include <experimental/memory_resource>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
+
+template <class _ValueT>
+using list = _VSTD::list<_ValueT, polymorphic_allocator<_ValueT>>;
+
+_LIBCPP_END_NAMESPACE_LFTS_PMR
+
+#endif /* _LIBCPP_EXPERIMENTAL_LIST */
diff --git a/include/experimental/map b/include/experimental/map
new file mode 100644
index 000000000000..cff2c5e52c0d
--- /dev/null
+++ b/include/experimental/map
@@ -0,0 +1,57 @@
+// -*- C++ -*-
+//===----------------------------- map ------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPERIMENTAL_MAP
+#define _LIBCPP_EXPERIMENTAL_MAP
+/*
+    experimental/map synopsis
+
+// C++1z
+namespace std {
+namespace experimental {
+inline namespace fundamentals_v1 {
+namespace pmr {
+
+  template <class Key, class T, class Compare = less<Key>>
+  using map = std::map<Key, T, Compare,
+                       polymorphic_allocator<pair<const Key,T>>>;
+
+  template <class Key, class T, class Compare = less<Key>>
+  using multimap = std::multimap<Key, T, Compare,
+                                 polymorphic_allocator<pair<const Key,T>>>;
+
+} // namespace pmr
+} // namespace fundamentals_v1
+} // namespace experimental
+} // namespace std
+
+ */
+
+#include <experimental/__config>
+#include <map>
+#include <experimental/memory_resource>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
+
+template <class _Key, class _Value, class  _Compare = less<_Key>>
+using map = _VSTD::map<_Key, _Value, _Compare,
+                        polymorphic_allocator<pair<const _Key, _Value>>>;
+
+template <class _Key, class _Value, class  _Compare = less<_Key>>
+using multimap = _VSTD::multimap<_Key, _Value, _Compare,
+                        polymorphic_allocator<pair<const _Key, _Value>>>;
+
+_LIBCPP_END_NAMESPACE_LFTS_PMR
+
+#endif /* _LIBCPP_EXPERIMENTAL_MAP */
diff --git a/include/experimental/memory_resource b/include/experimental/memory_resource
new file mode 100644
index 000000000000..9b345210ee5e
--- /dev/null
+++ b/include/experimental/memory_resource
@@ -0,0 +1,422 @@
+// -*- C++ -*-
+//===------------------------ memory_resource -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPERIMENTAL_MEMORY_RESOURCE
+#define _LIBCPP_EXPERIMENTAL_MEMORY_RESOURCE
+
+/**
+    experimental/memory_resource synopsis
+
+// C++1y
+
+namespace std {
+namespace experimental {
+inline namespace fundamentals_v1 {
+namespace pmr {
+
+  class memory_resource;
+
+  bool operator==(const memory_resource& a,
+                  const memory_resource& b) noexcept;
+  bool operator!=(const memory_resource& a,
+                  const memory_resource& b) noexcept;
+
+  template <class Tp> class polymorphic_allocator;
+
+  template <class T1, class T2>
+  bool operator==(const polymorphic_allocator<T1>& a,
+                  const polymorphic_allocator<T2>& b) noexcept;
+  template <class T1, class T2>
+  bool operator!=(const polymorphic_allocator<T1>& a,
+                  const polymorphic_allocator<T2>& b) noexcept;
+
+  // The name resource_adaptor_imp is for exposition only.
+  template <class Allocator> class resource_adaptor_imp;
+
+  template <class Allocator>
+    using resource_adaptor = resource_adaptor_imp<
+      allocator_traits<Allocator>::rebind_alloc<char>>;
+
+  // Global memory resources
+  memory_resource* new_delete_resource() noexcept;
+  memory_resource* null_memory_resource() noexcept;
+
+  // The default memory resource
+  memory_resource* set_default_resource(memory_resource* r) noexcept;
+  memory_resource* get_default_resource() noexcept;
+
+  // Standard memory resources
+  struct pool_options;
+  class synchronized_pool_resource;
+  class unsynchronized_pool_resource;
+  class monotonic_buffer_resource;
+
+} // namespace pmr
+} // namespace fundamentals_v1
+} // namespace experimental
+} // namespace std
+
+ */
+
+#include <experimental/__config>
+#include <experimental/__memory>
+#include <limits>
+#include <memory>
+#include <new>
+#include <stdexcept>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <cstddef>
+#include <cstdlib>
+#include <__debug>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
+
+// Round __s up to next multiple of __a.
+inline _LIBCPP_INLINE_VISIBILITY
+size_t __aligned_allocation_size(size_t __s, size_t __a) _NOEXCEPT
+{
+    _LIBCPP_ASSERT(__s + __a > __s, "aligned allocation size overflows");
+    return (__s + __a - 1) & ~(__a - 1);
+}
+
+// 8.5, memory.resource
+class _LIBCPP_TYPE_VIS_ONLY memory_resource
+{
+    static const size_t __max_align = alignof(max_align_t);
+
+// 8.5.2, memory.resource.public
+public:
+    virtual ~memory_resource() = default;
+
+    _LIBCPP_INLINE_VISIBILITY
+    void* allocate(size_t __bytes, size_t __align = __max_align)
+        { return do_allocate(__bytes, __align); }
+
+    _LIBCPP_INLINE_VISIBILITY
+    void deallocate(void * __p, size_t __bytes, size_t __align = __max_align)
+        { do_deallocate(__p, __bytes, __align); }
+
+    _LIBCPP_INLINE_VISIBILITY
+    bool is_equal(memory_resource const & __other) const _NOEXCEPT
+        { return do_is_equal(__other); }
+
+// 8.5.3, memory.resource.priv
+protected:
+    virtual void* do_allocate(size_t, size_t) = 0;
+    virtual void do_deallocate(void*, size_t, size_t) = 0;
+    virtual bool do_is_equal(memory_resource const &) const _NOEXCEPT = 0;
+};
+
+// 8.5.4, memory.resource.eq
+inline _LIBCPP_INLINE_VISIBILITY
+bool operator==(memory_resource const & __lhs,
+                memory_resource const & __rhs) _NOEXCEPT
+{
+    return &__lhs == &__rhs || __lhs.is_equal(__rhs);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool operator!=(memory_resource const & __lhs,
+                memory_resource const & __rhs) _NOEXCEPT
+{
+    return !(__lhs == __rhs);
+}
+
+_LIBCPP_FUNC_VIS
+memory_resource * new_delete_resource() _NOEXCEPT;
+
+_LIBCPP_FUNC_VIS
+memory_resource * null_memory_resource() _NOEXCEPT;
+
+_LIBCPP_FUNC_VIS
+memory_resource * get_default_resource() _NOEXCEPT;
+
+_LIBCPP_FUNC_VIS
+memory_resource * set_default_resource(memory_resource * __new_res) _NOEXCEPT;
+
+// 8.6, memory.polymorphic.allocator.class
+
+// 8.6.1, memory.polymorphic.allocator.overview
+template <class _ValueType>
+class _LIBCPP_TYPE_VIS_ONLY polymorphic_allocator
+{
+public:
+    typedef _ValueType value_type;
+
+    // 8.6.2, memory.polymorphic.allocator.ctor
+    _LIBCPP_INLINE_VISIBILITY
+    polymorphic_allocator() _NOEXCEPT
+      : __res_(_VSTD_LFTS_PMR::get_default_resource())
+    {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    polymorphic_allocator(memory_resource * __r) _NOEXCEPT
+      : __res_(__r)
+    {}
+
+    polymorphic_allocator(polymorphic_allocator const &) = default;
+
+    template <class _Tp>
+    _LIBCPP_INLINE_VISIBILITY
+    polymorphic_allocator(polymorphic_allocator<_Tp> const & __other) _NOEXCEPT
+      : __res_(__other.resource())
+    {}
+
+    polymorphic_allocator &
+    operator=(polymorphic_allocator const &) = delete;
+
+    // 8.6.3, memory.polymorphic.allocator.mem
+    _LIBCPP_INLINE_VISIBILITY
+    _ValueType* allocate(size_t __n) {
+        if (__n > max_size()) {
+            __libcpp_throw(length_error(
+                "std::experimental::pmr::polymorphic_allocator<T>::allocate(size_t n)"
+                " 'n' exceeds maximum supported size"));
+        }
+        return static_cast<_ValueType*>(
+            __res_->allocate(__n * sizeof(_ValueType), alignof(_ValueType))
+        );
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    void deallocate(_ValueType * __p, size_t __n) _NOEXCEPT {
+        _LIBCPP_ASSERT(__n <= max_size(),
+                       "deallocate called for size which exceeds max_size()");
+        __res_->deallocate(__p, __n * sizeof(_ValueType), alignof(_ValueType));
+    }
+
+    template <class _Tp, class ..._Ts>
+    _LIBCPP_INLINE_VISIBILITY
+    void construct(_Tp* __p, _Ts &&... __args)
+    {
+        _VSTD_LFTS::__lfts_user_alloc_construct(
+            __p, resource(), _VSTD::forward<_Ts>(__args)...
+          );
+    }
+
+    template <class _T1, class _T2, class ..._Args1, class ..._Args2>
+    _LIBCPP_INLINE_VISIBILITY
+    void construct(pair<_T1, _T2>* __p, piecewise_construct_t,
+                   tuple<_Args1...> __x, tuple<_Args2...> __y)
+    {
+        ::new ((void*)__p) pair<_T1, _T2>(piecewise_construct
+          , __transform_tuple(
+              typename __lfts_uses_alloc_ctor<
+                  _T1, memory_resource*, _Args1...
+              >::type()
+            , _VSTD::move(__x)
+            , typename __make_tuple_indices<sizeof...(_Args1)>::type{}
+          )
+          , __transform_tuple(
+              typename __lfts_uses_alloc_ctor<
+                  _T2, memory_resource*, _Args2...
+              >::type()
+            , _VSTD::move(__y)
+            , typename __make_tuple_indices<sizeof...(_Args2)>::type{}
+          )
+        );
+    }
+
+    template <class _T1, class _T2>
+    _LIBCPP_INLINE_VISIBILITY
+    void construct(pair<_T1, _T2>* __p) {
+        construct(__p, piecewise_construct, tuple<>(), tuple<>());
+    }
+
+    template <class _T1, class _T2, class _Up, class _Vp>
+    _LIBCPP_INLINE_VISIBILITY
+    void construct(pair<_T1, _T2> * __p, _Up && __u, _Vp && __v) {
+        construct(__p, piecewise_construct
+          , _VSTD::forward_as_tuple(_VSTD::forward<_Up>(__u))
+          , _VSTD::forward_as_tuple(_VSTD::forward<_Vp>(__v)));
+    }
+
+    template <class _T1, class _T2, class _U1, class _U2>
+    _LIBCPP_INLINE_VISIBILITY
+    void construct(pair<_T1, _T2> * __p, pair<_U1, _U2> const & __pr) {
+        construct(__p, piecewise_construct
+            , _VSTD::forward_as_tuple(__pr.first)
+            , _VSTD::forward_as_tuple(__pr.second));
+    }
+
+    template <class _T1, class _T2, class _U1, class _U2>
+    _LIBCPP_INLINE_VISIBILITY
+    void construct(pair<_T1, _T2> * __p, pair<_U1, _U2> && __pr){
+        construct(__p, piecewise_construct
+            , _VSTD::forward_as_tuple(_VSTD::forward<_U1>(__pr.first))
+            , _VSTD::forward_as_tuple(_VSTD::forward<_U2>(__pr.second)));
+    }
+
+    template <class _Tp>
+    _LIBCPP_INLINE_VISIBILITY
+    void destroy(_Tp * __p) _NOEXCEPT
+        { __p->~_Tp(); }
+
+    _LIBCPP_INLINE_VISIBILITY
+    size_t max_size() const _NOEXCEPT
+        { return numeric_limits<size_t>::max() / sizeof(value_type); }
+
+    _LIBCPP_INLINE_VISIBILITY
+    polymorphic_allocator
+    select_on_container_copy_construction() const _NOEXCEPT
+        { return polymorphic_allocator(); }
+
+    _LIBCPP_INLINE_VISIBILITY
+    memory_resource * resource() const _NOEXCEPT
+        { return __res_; }
+
+private:
+    template <class ..._Args, size_t ..._Idx>
+    _LIBCPP_INLINE_VISIBILITY
+    tuple<_Args&&...>
+    __transform_tuple(integral_constant<int, 0>, tuple<_Args...>&& __t,
+                      __tuple_indices<_Idx...>) const
+    {
+        return _VSTD::forward_as_tuple(_VSTD::get<_Idx>(_VSTD::move(__t))...);
+    }
+
+    template <class ..._Args, size_t ..._Idx>
+    _LIBCPP_INLINE_VISIBILITY
+    tuple<allocator_arg_t const&, memory_resource*, _Args&&...>
+    __transform_tuple(integral_constant<int, 1>, tuple<_Args...> && __t,
+                      __tuple_indices<_Idx...>) const
+    {
+        using _Tup = tuple<allocator_arg_t const&, memory_resource*, _Args&&...>;
+        return _Tup(allocator_arg, resource(),
+                    _VSTD::get<_Idx>(_VSTD::move(__t))...);
+    }
+
+    template <class ..._Args, size_t ..._Idx>
+    _LIBCPP_INLINE_VISIBILITY
+    tuple<_Args&&..., memory_resource*>
+    __transform_tuple(integral_constant<int, 2>, tuple<_Args...> && __t,
+                      __tuple_indices<_Idx...>) const
+    {
+        using _Tup = tuple<_Args&&..., memory_resource*>;
+        return _Tup(_VSTD::get<_Idx>(_VSTD::move(__t))..., resource());
+    }
+
+    memory_resource * __res_;
+};
+
+// 8.6.4, memory.polymorphic.allocator.eq
+
+template <class _Tp, class _Up>
+inline _LIBCPP_INLINE_VISIBILITY
+bool operator==(polymorphic_allocator<_Tp> const & __lhs,
+                polymorphic_allocator<_Up> const & __rhs) _NOEXCEPT
+{
+    return *__lhs.resource() == *__rhs.resource();
+}
+
+template <class _Tp, class _Up>
+inline _LIBCPP_INLINE_VISIBILITY
+bool operator!=(polymorphic_allocator<_Tp> const & __lhs,
+                polymorphic_allocator<_Up> const & __rhs) _NOEXCEPT
+{
+    return !(__lhs == __rhs);
+}
+
+// 8.7, memory.resource.adaptor
+
+// 8.7.1, memory.resource.adaptor.overview
+template <class _CharAlloc>
+class _LIBCPP_TYPE_VIS_ONLY __resource_adaptor_imp
+  : public memory_resource
+{
+    using _CTraits = allocator_traits<_CharAlloc>;
+    static_assert(is_same<typename _CTraits::value_type, char>::value
+               && is_same<typename _CTraits::pointer, char*>::value
+               && is_same<typename _CTraits::void_pointer, void*>::value, "");
+
+    static const size_t _MaxAlign = alignof(max_align_t);
+
+    using _Alloc = typename _CTraits::template rebind_alloc<
+            typename aligned_storage<_MaxAlign, _MaxAlign>::type
+        >;
+
+    using _ValueType = typename _Alloc::value_type;
+
+    _Alloc __alloc_;
+
+public:
+    typedef _CharAlloc allocator_type;
+
+    __resource_adaptor_imp() = default;
+    __resource_adaptor_imp(__resource_adaptor_imp const &) = default;
+    __resource_adaptor_imp(__resource_adaptor_imp &&) = default;
+
+    // 8.7.2, memory.resource.adaptor.ctor
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit __resource_adaptor_imp(allocator_type const & __a)
+      : __alloc_(__a)
+    {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit __resource_adaptor_imp(allocator_type && __a)
+      : __alloc_(_VSTD::move(__a))
+    {}
+
+    __resource_adaptor_imp &
+    operator=(__resource_adaptor_imp const &) = default;
+
+    _LIBCPP_INLINE_VISIBILITY
+    allocator_type get_allocator() const
+    { return __alloc_; }
+
+// 8.7.3, memory.resource.adaptor.mem
+protected:
+    virtual void * do_allocate(size_t __bytes, size_t)
+    {
+        if (__bytes > __max_size()) {
+            __libcpp_throw(length_error(
+                "std::experimental::pmr::resource_adaptor<T>::do_allocate(size_t bytes, size_t align)"
+                " 'bytes' exceeds maximum supported size"));
+        }
+        size_t __s = __aligned_allocation_size(__bytes, _MaxAlign) / _MaxAlign;
+        return __alloc_.allocate(__s);
+    }
+
+    virtual void do_deallocate(void * __p, size_t __bytes, size_t)
+    {
+        _LIBCPP_ASSERT(__bytes <= __max_size(),
+            "do_deallocate called for size which exceeds the maximum allocation size");
+        size_t __s = __aligned_allocation_size(__bytes, _MaxAlign) / _MaxAlign;
+        __alloc_.deallocate((_ValueType*)__p, __s);
+    }
+
+    virtual bool do_is_equal(memory_resource const & __other) const _NOEXCEPT {
+        __resource_adaptor_imp const * __p
+          = dynamic_cast<__resource_adaptor_imp const *>(&__other);
+        return __p  ? __alloc_ == __p->__alloc_ : false;
+    }
+
+private:
+    _LIBCPP_INLINE_VISIBILITY
+    size_t __max_size() const _NOEXCEPT {
+        return numeric_limits<size_t>::max() - _MaxAlign;
+    }
+};
+
+template <class _Alloc>
+using resource_adaptor = __resource_adaptor_imp<
+    typename allocator_traits<_Alloc>::template rebind_alloc<char>
+  >;
+
+_LIBCPP_END_NAMESPACE_LFTS_PMR
+
+#endif /* _LIBCPP_EXPERIMENTAL_MEMORY_RESOURCE */
diff --git a/include/experimental/optional b/include/experimental/optional
index a384882a1e12..3912438ec104 100644
--- a/include/experimental/optional
+++ b/include/experimental/optional
@@ -517,7 +517,11 @@ public:
     constexpr value_type const& value() const
     {
         if (!this->__engaged_)
+#ifndef _LIBCPP_NO_EXCEPTIONS
             throw bad_optional_access();
+#else
+            assert(!"bad optional access");
+#endif
         return this->__val_;
     }
 
@@ -525,7 +529,11 @@ public:
     value_type& value()
     {
         if (!this->__engaged_)
+#ifndef _LIBCPP_NO_EXCEPTIONS
             throw bad_optional_access();
+#else
+            assert(!"bad optional access");
+#endif
         return this->__val_;
     }
 
diff --git a/include/experimental/propagate_const b/include/experimental/propagate_const
new file mode 100644
index 000000000000..f267ba275c2f
--- /dev/null
+++ b/include/experimental/propagate_const
@@ -0,0 +1,576 @@
+// -*- C++ -*-
+//===------------------------ propagate_const -----------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPERIMENTAL_PROPAGATE_CONST
+#define _LIBCPP_EXPERIMENTAL_PROPAGATE_CONST
+/*
+    propagate_const synopsis
+
+    namespace std { namespace experimental { inline namespace fundamentals_v2 {
+
+    // [propagate_const]
+    template <class T> class propagate_const;
+
+    // [propagate_const.underlying], underlying pointer access
+    constexpr const _Tp& _VSTD_LFTS_V2::get_underlying(const propagate_const<T>& pt) noexcept;
+    constexpr T& _VSTD_LFTS_V2::get_underlying(propagate_const<T>& pt) noexcept;
+
+    // [propagate_const.relational], relational operators
+    template <class T> constexpr bool operator==(const propagate_const<T>& pt, nullptr_t);
+    template <class T> constexpr bool operator==(nullptr_t, const propagate_const<T>& pu);
+    template <class T> constexpr bool operator!=(const propagate_const<T>& pt, nullptr_t);
+    template <class T> constexpr bool operator!=(nullptr_t, const propagate_const<T>& pu);
+    template <class T, class U> constexpr bool operator==(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
+    template <class T, class U> constexpr bool operator!=(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
+    template <class T, class U> constexpr bool operator<(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
+    template <class T, class U> constexpr bool operator>(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
+    template <class T, class U> constexpr bool operator<=(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
+    template <class T, class U> constexpr bool operator>=(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
+    template <class T, class U> constexpr bool operator==(const propagate_const<T>& pt, const _Up& u);
+    template <class T, class U> constexpr bool operator!=(const propagate_const<T>& pt, const _Up& u);
+    template <class T, class U> constexpr bool operator<(const propagate_const<T>& pt, const _Up& u);
+    template <class T, class U> constexpr bool operator>(const propagate_const<T>& pt, const _Up& u);
+    template <class T, class U> constexpr bool operator<=(const propagate_const<T>& pt, const _Up& u);
+    template <class T, class U> constexpr bool operator>=(const propagate_const<T>& pt, const _Up& u);
+    template <class T, class U> constexpr bool operator==(const _Tp& t, const propagate_const<_Up>& pu);
+    template <class T, class U> constexpr bool operator!=(const _Tp& t, const propagate_const<_Up>& pu);
+    template <class T, class U> constexpr bool operator<(const _Tp& t, const propagate_const<_Up>& pu);
+    template <class T, class U> constexpr bool operator>(const _Tp& t, const propagate_const<_Up>& pu);
+    template <class T, class U> constexpr bool operator<=(const _Tp& t, const propagate_const<_Up>& pu);
+    template <class T, class U> constexpr bool operator>=(const _Tp& t, const propagate_const<_Up>& pu);
+
+    // [propagate_const.algorithms], specialized algorithms
+    template <class T> constexpr void swap(propagate_const<T>& pt, propagate_const<T>& pu) noexcept(see below);
+
+    template <class T>
+    class propagate_const
+    {
+
+    public:
+      typedef remove_reference_t<decltype(*declval<T&>())> element_type;
+
+      // [propagate_const.ctor], constructors
+      constexpr propagate_const() = default;
+      propagate_const(const propagate_const& p) = delete;
+      constexpr propagate_const(propagate_const&& p) = default;
+      template <class U> EXPLICIT constexpr propagate_const(propagate_const<_Up>&& pu); // see below
+      template <class U> EXPLICIT constexpr propagate_const(U&& u); // see below
+
+      // [propagate_const.assignment], assignment
+      propagate_const& operator=(const propagate_const& p) = delete;
+      constexpr propagate_const& operator=(propagate_const&& p) = default;
+      template <class U> constexpr propagate_const& operator=(propagate_const<_Up>&& pu);
+      template <class U> constexpr propagate_const& operator=(U&& u); // see below
+
+      // [propagate_const.const_observers], const observers
+      explicit constexpr operator bool() const;
+      constexpr const element_type* operator->() const;
+      constexpr operator const element_type*() const; // Not always defined
+      constexpr const element_type& operator*() const;
+      constexpr const element_type* get() const;
+
+      // [propagate_const.non_const_observers], non-const observers
+      constexpr element_type* operator->();
+      constexpr operator element_type*(); // Not always defined
+      constexpr element_type& operator*();
+      constexpr element_type* get();
+
+      // [propagate_const.modifiers], modifiers
+      constexpr void swap(propagate_const& pt) noexcept(see below)
+
+    private:
+      T t_; // exposition only
+    };
+
+  } // namespace fundamentals_v2
+  } // namespace experimental
+
+  // [propagate_const.hash], hash support
+  template <class T> struct hash<experimental::fundamentals_v2::propagate_const<T>>;
+
+  // [propagate_const.comparison_function_objects], comparison function objects
+  template <class T> struct equal_to<experimental::fundamentals_v2::propagate_const<T>>;
+  template <class T> struct not_equal_to<experimental::fundamentals_v2::propagate_const<T>>;
+  template <class T> struct less<experimental::fundamentals_v2::propagate_const<T>>;
+  template <class T> struct greater<experimental::fundamentals_v2::propagate_const<T>>;
+  template <class T> struct less_equal<experimental::fundamentals_v2::propagate_const<T>>;
+  template <class T> struct greater_equal<experimental::fundamentals_v2::propagate_const<T>>;
+
+} // namespace std
+
+*/
+
+#include <experimental/__config>
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER > 11
+
+#include <type_traits>
+#include <utility>
+#include <functional>
+
+_LIBCPP_BEGIN_NAMESPACE_LFTS_V2
+
+
+template <class _Tp>
+class propagate_const;
+template <class _Up> _LIBCPP_CONSTEXPR const _Up& get_underlying(const propagate_const<_Up>& __pu) _NOEXCEPT;
+template <class _Up> _LIBCPP_CONSTEXPR _Up& get_underlying(propagate_const<_Up>& __pu) _NOEXCEPT;
+
+template <class _Tp>
+class propagate_const
+{
+public:
+  typedef remove_reference_t<decltype(*_VSTD::declval<_Tp&>())> element_type;
+
+  static_assert(!is_array<_Tp>::value,
+      "Instantiation of propagate_const with an array type is ill-formed.");
+  static_assert(!is_reference<_Tp>::value,
+      "Instantiation of propagate_const with a reference type is ill-formed.");
+  static_assert(!(is_pointer<_Tp>::value && is_function<typename remove_pointer<_Tp>::type>::value),
+      "Instantiation of propagate_const with a function-pointer type is ill-formed.");
+  static_assert(!(is_pointer<_Tp>::value && is_same<typename remove_cv<typename remove_pointer<_Tp>::type>::type, void>::value),
+      "Instantiation of propagate_const with a pointer to (possibly cv-qualified) void is ill-formed.");
+
+private:
+  template <class _Up>
+  static _LIBCPP_CONSTEXPR element_type* __get_pointer(_Up* __u)
+  {
+    return __u;
+  }
+
+  template <class _Up>
+  static _LIBCPP_CONSTEXPR element_type* __get_pointer(_Up& __u)
+  {
+    return __get_pointer(__u.get());
+  }
+
+  template <class _Up>
+  static _LIBCPP_CONSTEXPR const element_type* __get_pointer(const _Up* __u)
+  {
+    return __u;
+  }
+
+  template <class _Up>
+  static _LIBCPP_CONSTEXPR const element_type* __get_pointer(const _Up& __u)
+  {
+    return __get_pointer(__u.get());
+  }
+
+  template <class _Up>
+  struct __is_propagate_const : false_type
+  {
+  };
+
+  template <class _Up>
+  struct __is_propagate_const<propagate_const<_Up>> : true_type
+  {
+  };
+
+  _Tp __t_;
+
+public:
+
+  template <class _Up> friend _LIBCPP_CONSTEXPR const _Up& ::_VSTD_LFTS_V2::get_underlying(const propagate_const<_Up>& __pu) _NOEXCEPT;
+  template <class _Up> friend _LIBCPP_CONSTEXPR _Up& ::_VSTD_LFTS_V2::get_underlying(propagate_const<_Up>& __pu) _NOEXCEPT;
+
+  _LIBCPP_CONSTEXPR propagate_const() = default;
+
+  propagate_const(const propagate_const&) = delete;
+
+  _LIBCPP_CONSTEXPR propagate_const(propagate_const&&) = default;
+
+  template <class _Up, enable_if_t<!is_convertible<_Up, _Tp>::value &&
+                                 is_constructible<_Tp, _Up&&>::value,bool> = true>
+  explicit _LIBCPP_CONSTEXPR propagate_const(propagate_const<_Up>&& __pu)
+      : __t_(std::move(_VSTD_LFTS_V2::get_underlying(__pu)))
+  {
+  }
+
+  template <class _Up, enable_if_t<is_convertible<_Up&&, _Tp>::value &&
+                                 is_constructible<_Tp, _Up&&>::value,bool> = false>
+  _LIBCPP_CONSTEXPR propagate_const(propagate_const<_Up>&& __pu)
+      : __t_(std::move(_VSTD_LFTS_V2::get_underlying(__pu)))
+  {
+  }
+
+  template <class _Up, enable_if_t<!is_convertible<_Up&&, _Tp>::value &&
+                                 is_constructible<_Tp, _Up&&>::value &&
+                                 !__is_propagate_const<decay_t<_Up>>::value,bool> = true>
+  explicit _LIBCPP_CONSTEXPR propagate_const(_Up&& __u)
+      : __t_(std::forward<_Up>(__u))
+  {
+  }
+
+  template <class _Up, enable_if_t<is_convertible<_Up&&, _Tp>::value &&
+                                 is_constructible<_Tp, _Up&&>::value &&
+                                 !__is_propagate_const<decay_t<_Up>>::value,bool> = false>
+  _LIBCPP_CONSTEXPR propagate_const(_Up&& __u)
+      : __t_(std::forward<_Up>(__u))
+  {
+  }
+
+  propagate_const& operator=(const propagate_const&) = delete;
+
+  _LIBCPP_CONSTEXPR propagate_const& operator=(propagate_const&&) = default;
+
+  template <class _Up>
+  _LIBCPP_CONSTEXPR propagate_const& operator=(propagate_const<_Up>&& __pu)
+  {
+    __t_ = std::move(_VSTD_LFTS_V2::get_underlying(__pu));
+    return *this;
+  }
+
+  template <class _Up, class _Vp = enable_if_t<!__is_propagate_const<decay_t<_Up>>::value>>
+  _LIBCPP_CONSTEXPR propagate_const& operator=(_Up&& __u)
+  {
+    __t_ = std::forward<_Up>(__u);
+    return *this;
+  }
+
+  _LIBCPP_CONSTEXPR const element_type* get() const
+  {
+    return __get_pointer(__t_);
+  }
+
+  _LIBCPP_CONSTEXPR element_type* get()
+  {
+    return __get_pointer(__t_);
+  }
+
+  explicit _LIBCPP_CONSTEXPR operator bool() const
+  {
+    return get() != nullptr;
+  }
+
+  _LIBCPP_CONSTEXPR const element_type* operator->() const
+  {
+    return get();
+  }
+
+  template <class _Tp_ = _Tp, class _Up = enable_if_t<is_convertible<
+                                  const _Tp_, const element_type *>::value>>
+  _LIBCPP_CONSTEXPR operator const element_type *() const {
+    return get();
+  }
+
+  _LIBCPP_CONSTEXPR const element_type& operator*() const
+  {
+    return *get();
+  }
+
+  _LIBCPP_CONSTEXPR element_type* operator->()
+  {
+    return get();
+  }
+
+  template <class _Tp_ = _Tp, class _Up = enable_if_t<
+                                  is_convertible<_Tp_, element_type *>::value>>
+  _LIBCPP_CONSTEXPR operator element_type *() {
+    return get();
+  }
+
+  _LIBCPP_CONSTEXPR element_type& operator*()
+  {
+    return *get();
+  }
+
+  _LIBCPP_CONSTEXPR void swap(propagate_const& __pt) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
+  {
+    using _VSTD::swap;
+    swap(__t_, __pt.__t_);
+  }
+};
+
+
+template <class _Tp>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt, nullptr_t)
+{
+  return _VSTD_LFTS_V2::get_underlying(__pt) == nullptr;
+}
+
+template <class _Tp>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator==(nullptr_t, const propagate_const<_Tp>& __pt)
+{
+  return nullptr == _VSTD_LFTS_V2::get_underlying(__pt);
+}
+
+template <class _Tp>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt, nullptr_t)
+{
+  return _VSTD_LFTS_V2::get_underlying(__pt) != nullptr;
+}
+
+template <class _Tp>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator!=(nullptr_t, const propagate_const<_Tp>& __pt)
+{
+  return nullptr != _VSTD_LFTS_V2::get_underlying(__pt);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt,
+                          const propagate_const<_Up>& __pu)
+{
+  return _VSTD_LFTS_V2::get_underlying(__pt) == _VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt,
+                          const propagate_const<_Up>& __pu)
+{
+  return _VSTD_LFTS_V2::get_underlying(__pt) != _VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator<(const propagate_const<_Tp>& __pt,
+                         const propagate_const<_Up>& __pu)
+{
+  return _VSTD_LFTS_V2::get_underlying(__pt) < _VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator>(const propagate_const<_Tp>& __pt,
+                         const propagate_const<_Up>& __pu)
+{
+  return _VSTD_LFTS_V2::get_underlying(__pt) > _VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator<=(const propagate_const<_Tp>& __pt,
+                          const propagate_const<_Up>& __pu)
+{
+  return _VSTD_LFTS_V2::get_underlying(__pt) <= _VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator>=(const propagate_const<_Tp>& __pt,
+                          const propagate_const<_Up>& __pu)
+{
+  return _VSTD_LFTS_V2::get_underlying(__pt) >= _VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt, const _Up& __u)
+{
+  return _VSTD_LFTS_V2::get_underlying(__pt) == __u;
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt, const _Up& __u)
+{
+  return _VSTD_LFTS_V2::get_underlying(__pt) != __u;
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator<(const propagate_const<_Tp>& __pt, const _Up& __u)
+{
+  return _VSTD_LFTS_V2::get_underlying(__pt) < __u;
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator>(const propagate_const<_Tp>& __pt, const _Up& __u)
+{
+  return _VSTD_LFTS_V2::get_underlying(__pt) > __u;
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator<=(const propagate_const<_Tp>& __pt, const _Up& __u)
+{
+  return _VSTD_LFTS_V2::get_underlying(__pt) <= __u;
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator>=(const propagate_const<_Tp>& __pt, const _Up& __u)
+{
+  return _VSTD_LFTS_V2::get_underlying(__pt) >= __u;
+}
+
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator==(const _Tp& __t, const propagate_const<_Up>& __pu)
+{
+  return __t == _VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator!=(const _Tp& __t, const propagate_const<_Up>& __pu)
+{
+  return __t != _VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator<(const _Tp& __t, const propagate_const<_Up>& __pu)
+{
+  return __t < _VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator>(const _Tp& __t, const propagate_const<_Up>& __pu)
+{
+  return __t > _VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator<=(const _Tp& __t, const propagate_const<_Up>& __pu)
+{
+  return __t <= _VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator>=(const _Tp& __t, const propagate_const<_Up>& __pu)
+{
+  return __t >= _VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR void swap(propagate_const<_Tp>& __pc1, propagate_const<_Tp>& __pc2) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
+{
+  using _VSTD::swap;
+  swap(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
+}
+
+template <class _Tp>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR const _Tp& get_underlying(const propagate_const<_Tp>& __pt) _NOEXCEPT
+{
+  return __pt.__t_;
+}
+
+template <class _Tp>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR _Tp& get_underlying(propagate_const<_Tp>& __pt) _NOEXCEPT
+{
+  return __pt.__t_;
+}
+
+_LIBCPP_END_NAMESPACE_LFTS_V2
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct hash<experimental::fundamentals_v2::propagate_const<_Tp>>
+{
+  typedef size_t result_type;
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> argument_type;
+
+  size_t operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1) const
+  {
+    return std::hash<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1));
+  }
+};
+
+template <class _Tp>
+struct equal_to<experimental::fundamentals_v2::propagate_const<_Tp>>
+{
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+
+  bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
+      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
+  {
+    return std::equal_to<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
+  }
+};
+
+template <class _Tp>
+struct not_equal_to<experimental::fundamentals_v2::propagate_const<_Tp>>
+{
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+
+  bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
+      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
+  {
+    return std::not_equal_to<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
+  }
+};
+
+template <class _Tp>
+struct less<experimental::fundamentals_v2::propagate_const<_Tp>>
+{
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+
+  bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
+      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
+  {
+    return std::less<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
+  }
+};
+
+template <class _Tp>
+struct greater<experimental::fundamentals_v2::propagate_const<_Tp>>
+{
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+
+  bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
+      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
+  {
+    return std::greater<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
+  }
+};
+
+template <class _Tp>
+struct less_equal<experimental::fundamentals_v2::propagate_const<_Tp>>
+{
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+
+  bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
+      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
+  {
+    return std::less_equal<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
+  }
+};
+
+template <class _Tp>
+struct greater_equal<experimental::fundamentals_v2::propagate_const<_Tp>>
+{
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+
+  bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
+      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
+  {
+    return std::greater_equal<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
+  }
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER > 11
+#endif // _LIBCPP_EXPERIMENTAL_PROPAGATE_CONST
+
diff --git a/include/experimental/regex b/include/experimental/regex
new file mode 100644
index 000000000000..d38891c374bb
--- /dev/null
+++ b/include/experimental/regex
@@ -0,0 +1,62 @@
+// -*- C++ -*-
+//===----------------------------- regex ----------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPERIMENTAL_REGEX
+#define _LIBCPP_EXPERIMENTAL_REGEX
+/*
+    experimental/regex synopsis
+
+// C++1z
+namespace std {
+namespace experimental {
+inline namespace fundamentals_v1 {
+namespace pmr {
+
+  template <class BidirectionalIterator>
+  using match_results =
+    std::match_results<BidirectionalIterator,
+                       polymorphic_allocator<sub_match<BidirectionalIterator>>>;
+
+  typedef match_results<const char*> cmatch;
+  typedef match_results<const wchar_t*> wcmatch;
+  typedef match_results<string::const_iterator> smatch;
+  typedef match_results<wstring::const_iterator> wsmatch;
+
+} // namespace pmr
+} // namespace fundamentals_v1
+} // namespace experimental
+} // namespace std
+
+ */
+
+#include <experimental/__config>
+#include <regex>
+#include <experimental/string>
+#include <experimental/memory_resource>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
+
+template <class _BiDirIter>
+using match_results =
+    _VSTD::match_results<_BiDirIter,
+        polymorphic_allocator<_VSTD::sub_match<_BiDirIter>>>;
+
+typedef match_results<const char*> cmatch;
+typedef match_results<const wchar_t*> wcmatch;
+typedef match_results<_VSTD_LFTS_PMR::string::const_iterator> smatch;
+typedef match_results<_VSTD_LFTS_PMR::wstring::const_iterator> wsmatch;
+
+_LIBCPP_END_NAMESPACE_LFTS_PMR
+
+#endif /* _LIBCPP_EXPERIMENTAL_REGEX */
diff --git a/include/experimental/set b/include/experimental/set
new file mode 100644
index 000000000000..20cf6d4a3890
--- /dev/null
+++ b/include/experimental/set
@@ -0,0 +1,57 @@
+// -*- C++ -*-
+//===--------------------------- list ------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPERIMENTAL_SET
+#define _LIBCPP_EXPERIMENTAL_SET
+/*
+    experimental/set synopsis
+
+// C++1z
+namespace std {
+namespace experimental {
+inline namespace fundamentals_v1 {
+namespace pmr {
+
+  template <class Key, class T, class Compare = less<Key>>
+  using set = std::set<Key, T, Compare,
+                       polymorphic_allocator<pair<const Key,T>>>;
+
+  template <class Key, class T, class Compare = less<Key>>
+  using multiset = std::multiset<Key, T, Compare,
+                                 polymorphic_allocator<pair<const Key,T>>>;
+
+} // namespace pmr
+} // namespace fundamentals_v1
+} // namespace experimental
+} // namespace std
+
+ */
+
+#include <experimental/__config>
+#include <set>
+#include <experimental/memory_resource>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
+
+template <class _Value, class  _Compare = less<_Value>>
+using set = _VSTD::set<_Value, _Compare,
+                        polymorphic_allocator<_Value>>;
+
+template <class _Value, class  _Compare = less<_Value>>
+using multiset = _VSTD::multiset<_Value, _Compare,
+                        polymorphic_allocator<_Value>>;
+
+_LIBCPP_END_NAMESPACE_LFTS_PMR
+
+#endif /* _LIBCPP_EXPERIMENTAL_SET */
diff --git a/include/experimental/string b/include/experimental/string
new file mode 100644
index 000000000000..8b8545128f2a
--- /dev/null
+++ b/include/experimental/string
@@ -0,0 +1,62 @@
+// -*- C++ -*-
+//===--------------------------- string ----------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPERIMENTAL_STRING
+#define _LIBCPP_EXPERIMENTAL_STRING
+/*
+    experimental/string synopsis
+
+// C++1z
+namespace std {
+namespace experimental {
+inline namespace fundamentals_v1 {
+namespace pmr {
+
+  // basic_string using polymorphic allocator in namespace pmr
+  template <class charT, class traits = char_traits<charT>>
+   using basic_string =
+     std::basic_string<charT, traits, polymorphic_allocator<charT>>;
+
+  // basic_string typedef names using polymorphic allocator in namespace
+  // std::experimental::pmr
+  typedef basic_string<char> string;
+  typedef basic_string<char16_t> u16string;
+  typedef basic_string<char32_t> u32string;
+  typedef basic_string<wchar_t> wstring;
+
+} // namespace pmr
+} // namespace fundamentals_v1
+} // namespace experimental
+} // namespace std
+
+ */
+
+#include <experimental/__config>
+#include <string>
+#include <experimental/memory_resource>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
+
+template <class _CharT, class _Traits = char_traits<_CharT>>
+using basic_string =
+    _VSTD::basic_string<_CharT, _Traits, polymorphic_allocator<_CharT>>;
+
+typedef basic_string<char> string;
+typedef basic_string<char16_t> u16string;
+typedef basic_string<char32_t> u32string;
+typedef basic_string<wchar_t> wstring;
+
+_LIBCPP_END_NAMESPACE_LFTS_PMR
+
+#endif /* _LIBCPP_EXPERIMENTAL_STRING */
diff --git a/include/experimental/string_view b/include/experimental/string_view
index 2a20d7caa687..0a7239b4c0bb 100644
--- a/include/experimental/string_view
+++ b/include/experimental/string_view
@@ -180,6 +180,7 @@ namespace std {
 #include <algorithm>
 #include <iterator>
 #include <ostream>
+#include <stdexcept>
 #include <iomanip>
 
 #include <__debug>
@@ -227,7 +228,7 @@ _LIBCPP_BEGIN_NAMESPACE_LFTS
         basic_string_view(const _CharT* __s, size_type __len)
             : __data(__s), __size(__len)
         {
-//             _LIBCPP_ASSERT(__len == 0 || __s != nullptr, "string_view::string_view(_CharT *, size_t): recieved nullptr");
+//             _LIBCPP_ASSERT(__len == 0 || __s != nullptr, "string_view::string_view(_CharT *, size_t): received nullptr");
         }
 
         _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
@@ -280,7 +281,7 @@ _LIBCPP_BEGIN_NAMESPACE_LFTS
         const_reference at(size_type __pos) const
         {
             return __pos >= size()
-                ? (throw out_of_range("string_view::at"), __data[0])
+                ? (__libcpp_throw(out_of_range("string_view::at")), __data[0])
                 : __data[__pos];
         }
 
@@ -351,7 +352,7 @@ _LIBCPP_BEGIN_NAMESPACE_LFTS
         size_type copy(_CharT* __s, size_type __n, size_type __pos = 0) const
         {
             if ( __pos > size())
-                throw out_of_range("string_view::copy");
+                __libcpp_throw(out_of_range("string_view::copy"));
             size_type __rlen = _VSTD::min( __n, size() - __pos );
             _VSTD::copy_n(begin() + __pos, __rlen, __s );
             return __rlen;
@@ -365,7 +366,7 @@ _LIBCPP_BEGIN_NAMESPACE_LFTS
 //             size_type __rlen = _VSTD::min( __n, size() - __pos );
 //             return basic_string_view(data() + __pos, __rlen);
             return __pos > size()
-                ? throw out_of_range("string_view::substr")
+                ? (__libcpp_throw((out_of_range("string_view::substr"))), basic_string_view())
                 : basic_string_view(data() + __pos, _VSTD::min(__n, size() - __pos));
         }
 
@@ -413,7 +414,7 @@ _LIBCPP_BEGIN_NAMESPACE_LFTS
         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
         size_type find(basic_string_view __s, size_type __pos = 0) const _NOEXCEPT
         {
-            _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find(): recieved nullptr");
+            _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find(): received nullptr");
             return _VSTD::__str_find<value_type, size_type, traits_type, npos>
                 (data(), size(), __s.data(), __pos, __s.size());
         }
@@ -428,7 +429,7 @@ _LIBCPP_BEGIN_NAMESPACE_LFTS
         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
         size_type find(const _CharT* __s, size_type __pos, size_type __n) const
         {
-            _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find(): recieved nullptr");
+            _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find(): received nullptr");
             return _VSTD::__str_find<value_type, size_type, traits_type, npos>
                 (data(), size(), __s, __pos, __n);
         }
@@ -436,7 +437,7 @@ _LIBCPP_BEGIN_NAMESPACE_LFTS
         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
         size_type find(const _CharT* __s, size_type __pos = 0) const
         {
-            _LIBCPP_ASSERT(__s != nullptr, "string_view::find(): recieved nullptr");
+            _LIBCPP_ASSERT(__s != nullptr, "string_view::find(): received nullptr");
             return _VSTD::__str_find<value_type, size_type, traits_type, npos>
                 (data(), size(), __s, __pos, traits_type::length(__s));
         }
@@ -445,7 +446,7 @@ _LIBCPP_BEGIN_NAMESPACE_LFTS
         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
         size_type rfind(basic_string_view __s, size_type __pos = npos) const _NOEXCEPT
         {
-            _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find(): recieved nullptr");
+            _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find(): received nullptr");
             return _VSTD::__str_rfind<value_type, size_type, traits_type, npos>
                 (data(), size(), __s.data(), __pos, __s.size());
         }
@@ -460,7 +461,7 @@ _LIBCPP_BEGIN_NAMESPACE_LFTS
         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
         size_type rfind(const _CharT* __s, size_type __pos, size_type __n) const
         {
-            _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::rfind(): recieved nullptr");
+            _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::rfind(): received nullptr");
             return _VSTD::__str_rfind<value_type, size_type, traits_type, npos>
                 (data(), size(), __s, __pos, __n);
         }
@@ -468,7 +469,7 @@ _LIBCPP_BEGIN_NAMESPACE_LFTS
         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
         size_type rfind(const _CharT* __s, size_type __pos=npos) const
         {
-            _LIBCPP_ASSERT(__s != nullptr, "string_view::rfind(): recieved nullptr");
+            _LIBCPP_ASSERT(__s != nullptr, "string_view::rfind(): received nullptr");
             return _VSTD::__str_rfind<value_type, size_type, traits_type, npos>
                 (data(), size(), __s, __pos, traits_type::length(__s));
         }
@@ -477,7 +478,7 @@ _LIBCPP_BEGIN_NAMESPACE_LFTS
         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
         size_type find_first_of(basic_string_view __s, size_type __pos = 0) const _NOEXCEPT
         {
-            _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_first_of(): recieved nullptr");
+            _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_first_of(): received nullptr");
             return _VSTD::__str_find_first_of<value_type, size_type, traits_type, npos>
                 (data(), size(), __s.data(), __pos, __s.size());
         }
@@ -489,7 +490,7 @@ _LIBCPP_BEGIN_NAMESPACE_LFTS
         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
         size_type find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
         {
-            _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_first_of(): recieved nullptr");
+            _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_first_of(): received nullptr");
             return _VSTD::__str_find_first_of<value_type, size_type, traits_type, npos>
                 (data(), size(), __s, __pos, __n);
         }
@@ -497,7 +498,7 @@ _LIBCPP_BEGIN_NAMESPACE_LFTS
         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
         size_type find_first_of(const _CharT* __s, size_type __pos=0) const
         {
-            _LIBCPP_ASSERT(__s != nullptr, "string_view::find_first_of(): recieved nullptr");
+            _LIBCPP_ASSERT(__s != nullptr, "string_view::find_first_of(): received nullptr");
             return _VSTD::__str_find_first_of<value_type, size_type, traits_type, npos>
                 (data(), size(), __s, __pos, traits_type::length(__s));
         }
@@ -506,7 +507,7 @@ _LIBCPP_BEGIN_NAMESPACE_LFTS
         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
         size_type find_last_of(basic_string_view __s, size_type __pos=npos) const _NOEXCEPT
         {
-            _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_last_of(): recieved nullptr");
+            _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_last_of(): received nullptr");
             return _VSTD::__str_find_last_of<value_type, size_type, traits_type, npos>
                 (data(), size(), __s.data(), __pos, __s.size());
         }
@@ -518,7 +519,7 @@ _LIBCPP_BEGIN_NAMESPACE_LFTS
         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
         size_type find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
         {
-            _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_last_of(): recieved nullptr");
+            _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_last_of(): received nullptr");
             return _VSTD::__str_find_last_of<value_type, size_type, traits_type, npos>
                 (data(), size(), __s, __pos, __n);
         }
@@ -526,7 +527,7 @@ _LIBCPP_BEGIN_NAMESPACE_LFTS
         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
         size_type find_last_of(const _CharT* __s, size_type __pos=npos) const
         {
-            _LIBCPP_ASSERT(__s != nullptr, "string_view::find_last_of(): recieved nullptr");
+            _LIBCPP_ASSERT(__s != nullptr, "string_view::find_last_of(): received nullptr");
             return _VSTD::__str_find_last_of<value_type, size_type, traits_type, npos>
                 (data(), size(), __s, __pos, traits_type::length(__s));
         }
@@ -535,7 +536,7 @@ _LIBCPP_BEGIN_NAMESPACE_LFTS
         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
         size_type find_first_not_of(basic_string_view __s, size_type __pos=0) const _NOEXCEPT
         {
-            _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_first_not_of(): recieved nullptr");
+            _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_first_not_of(): received nullptr");
             return _VSTD::__str_find_first_not_of<value_type, size_type, traits_type, npos>
                 (data(), size(), __s.data(), __pos, __s.size());
         }
@@ -550,7 +551,7 @@ _LIBCPP_BEGIN_NAMESPACE_LFTS
         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
         size_type find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
         {
-            _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_first_not_of(): recieved nullptr");
+            _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_first_not_of(): received nullptr");
             return _VSTD::__str_find_first_not_of<value_type, size_type, traits_type, npos>
                 (data(), size(), __s, __pos, __n);
         }
@@ -558,7 +559,7 @@ _LIBCPP_BEGIN_NAMESPACE_LFTS
         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
         size_type find_first_not_of(const _CharT* __s, size_type __pos=0) const
         {
-            _LIBCPP_ASSERT(__s != nullptr, "string_view::find_first_not_of(): recieved nullptr");
+            _LIBCPP_ASSERT(__s != nullptr, "string_view::find_first_not_of(): received nullptr");
             return _VSTD::__str_find_first_not_of<value_type, size_type, traits_type, npos>
                 (data(), size(), __s, __pos, traits_type::length(__s));
         }
@@ -567,7 +568,7 @@ _LIBCPP_BEGIN_NAMESPACE_LFTS
         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
         size_type find_last_not_of(basic_string_view __s, size_type __pos=npos) const _NOEXCEPT
         {
-            _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_last_not_of(): recieved nullptr");
+            _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_last_not_of(): received nullptr");
             return _VSTD::__str_find_last_not_of<value_type, size_type, traits_type, npos>
                 (data(), size(), __s.data(), __pos, __s.size());
         }
@@ -582,7 +583,7 @@ _LIBCPP_BEGIN_NAMESPACE_LFTS
         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
         size_type find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
         {
-            _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_last_not_of(): recieved nullptr");
+            _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_last_not_of(): received nullptr");
             return _VSTD::__str_find_last_not_of<value_type, size_type, traits_type, npos>
                 (data(), size(), __s, __pos, __n);
         }
@@ -590,7 +591,7 @@ _LIBCPP_BEGIN_NAMESPACE_LFTS
         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
         size_type find_last_not_of(const _CharT* __s, size_type __pos=npos) const
         {
-            _LIBCPP_ASSERT(__s != nullptr, "string_view::find_last_not_of(): recieved nullptr");
+            _LIBCPP_ASSERT(__s != nullptr, "string_view::find_last_not_of(): received nullptr");
             return _VSTD::__str_find_last_not_of<value_type, size_type, traits_type, npos>
                 (data(), size(), __s, __pos, traits_type::length(__s));
         }
diff --git a/include/experimental/tuple b/include/experimental/tuple
index 50d1e0555bc4..e00d2ec1a92f 100644
--- a/include/experimental/tuple
+++ b/include/experimental/tuple
@@ -57,9 +57,10 @@ _LIBCPP_CONSTEXPR size_t tuple_size_v = tuple_size<_Tp>::value;
 
 template <class _Fn, class _Tuple, size_t ..._Id>
 inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR_AFTER_CXX11
 decltype(auto) __apply_tuple_impl(_Fn && __f, _Tuple && __t,
                                   integer_sequence<size_t, _Id...>) {
-    return _VSTD::__invoke(
+    return _VSTD::__invoke_constexpr(
         _VSTD::forward<_Fn>(__f),
         _VSTD::get<_Id>(_VSTD::forward<_Tuple>(__t))...
     );
diff --git a/include/experimental/unordered_map b/include/experimental/unordered_map
new file mode 100644
index 000000000000..1f998c2d4c7e
--- /dev/null
+++ b/include/experimental/unordered_map
@@ -0,0 +1,65 @@
+// -*- C++ -*-
+//===------------------------- unordered_map ------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPERIMENTAL_UNORDERED_MAP
+#define _LIBCPP_EXPERIMENTAL_UNORDERED_MAP
+/*
+    experimental/unordered_map synopsis
+
+// C++1z
+namespace std {
+namespace experimental {
+inline namespace fundamentals_v1 {
+namespace pmr {
+
+  template <class Key, class T,
+            class Hash = hash<Key>,
+            class Pred = equal_to<Key>>
+  using unordered_map =
+    std::unordered_map<Key, T, Hash, Pred,
+                       polymorphic_allocator<pair<const Key,T>>>;
+
+  template <class Key, class T,
+            class Hash = hash<Key>,
+            class Pred = equal_to<Key>>
+  using unordered_multimap =
+    std::unordered_multimap<Key, T, Hash, Pred,
+                            polymorphic_allocator<pair<const Key,T>>>;
+
+} // namespace pmr
+} // namespace fundamentals_v1
+} // namespace experimental
+} // namespace std
+
+ */
+
+#include <experimental/__config>
+#include <unordered_map>
+#include <experimental/memory_resource>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
+
+template <class _Key, class _Value,
+          class _Hash = hash<_Key>, class _Pred = equal_to<_Key>>
+using unordered_map = _VSTD::unordered_map<_Key, _Value, _Hash, _Pred,
+                        polymorphic_allocator<pair<const _Key, _Value>>>;
+
+template <class _Key, class _Value,
+          class _Hash = hash<_Key>, class _Pred = equal_to<_Key>>
+using unordered_multimap = _VSTD::unordered_multimap<_Key, _Value, _Hash, _Pred,
+                        polymorphic_allocator<pair<const _Key, _Value>>>;
+
+_LIBCPP_END_NAMESPACE_LFTS_PMR
+
+#endif /* _LIBCPP_EXPERIMENTAL_UNORDERED_MAP */
diff --git a/include/experimental/unordered_set b/include/experimental/unordered_set
new file mode 100644
index 000000000000..d00a83753401
--- /dev/null
+++ b/include/experimental/unordered_set
@@ -0,0 +1,59 @@
+// -*- C++ -*-
+//===------------------------- unordered_set ------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPERIMENTAL_UNORDERED_SET
+#define _LIBCPP_EXPERIMENTAL_UNORDERED_SET
+/*
+    experimental/unordered_set synopsis
+
+// C++1z
+namespace std {
+namespace experimental {
+inline namespace fundamentals_v1 {
+namespace pmr {
+
+  template <class T, class Hash = hash<T>, class Pred = equal_to<T>>
+  using unordered_set = std::unordered_set<T, Hash, Pred,
+                       polymorphic_allocator<T>>;
+
+  template <class T, class Hash = hash<T>, class Pred = equal_to<T>>
+  using unordered_multiset = std::unordered_multiset<T, Hash, Pred,
+                       polymorphic_allocator<T>>;
+
+} // namespace pmr
+} // namespace fundamentals_v1
+} // namespace experimental
+} // namespace std
+
+ */
+
+#include <experimental/__config>
+#include <unordered_set>
+#include <experimental/memory_resource>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
+
+template <class _Value,
+          class _Hash = hash<_Value>, class _Pred = equal_to<_Value>>
+using unordered_set = _VSTD::unordered_set<_Value, _Hash, _Pred,
+                        polymorphic_allocator<_Value>>;
+
+template <class _Value,
+          class _Hash = hash<_Value>, class _Pred = equal_to<_Value>>
+using unordered_multiset = _VSTD::unordered_multiset<_Value, _Hash, _Pred,
+                        polymorphic_allocator<_Value>>;
+
+_LIBCPP_END_NAMESPACE_LFTS_PMR
+
+#endif /* _LIBCPP_EXPERIMENTAL_UNORDERED_SET */
diff --git a/include/experimental/vector b/include/experimental/vector
new file mode 100644
index 000000000000..bd10492bfefc
--- /dev/null
+++ b/include/experimental/vector
@@ -0,0 +1,47 @@
+// -*- C++ -*-
+//===--------------------------- vector ------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPERIMENTAL_VECTOR
+#define _LIBCPP_EXPERIMENTAL_VECTOR
+/*
+    experimental/vector synopsis
+
+// C++1z
+namespace std {
+namespace experimental {
+inline namespace fundamentals_v1 {
+namespace pmr {
+
+  template <class T>
+  using vector = std::vector<T, polymorphic_allocator<T>>;
+
+} // namespace pmr
+} // namespace fundamentals_v1
+} // namespace experimental
+} // namespace std
+
+ */
+
+#include <experimental/__config>
+#include <vector>
+#include <experimental/memory_resource>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
+
+template <class _ValueT>
+using vector = _VSTD::vector<_ValueT, polymorphic_allocator<_ValueT>>;
+
+_LIBCPP_END_NAMESPACE_LFTS_PMR
+
+#endif /* _LIBCPP_EXPERIMENTAL_VECTOR */
diff --git a/include/ext/hash_map b/include/ext/hash_map
index 3ac27b2ca330..5e1e9f542b17 100644
--- a/include/ext/hash_map
+++ b/include/ext/hash_map
@@ -309,7 +309,7 @@ class __hash_map_node_destructor
 {
     typedef _Alloc                              allocator_type;
     typedef allocator_traits<allocator_type>    __alloc_traits;
-    typedef typename __alloc_traits::value_type::value_type value_type;
+    typedef typename __alloc_traits::value_type::__node_value_type value_type;
 public:
     typedef typename __alloc_traits::pointer    pointer;
 private:
@@ -549,6 +549,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     iterator insert(const_iterator, const value_type& __x) {return insert(__x).first;}
     template <class _InputIterator>
+        _LIBCPP_INLINE_VISIBILITY
         void insert(_InputIterator __first, _InputIterator __last);
 
     _LIBCPP_INLINE_VISIBILITY
@@ -674,7 +675,7 @@ hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(const key_type& __k)
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 template <class _InputIterator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
                                                        _InputIterator __last)
@@ -820,6 +821,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     iterator insert(const_iterator, const value_type& __x) {return insert(__x);}
     template <class _InputIterator>
+        _LIBCPP_INLINE_VISIBILITY
         void insert(_InputIterator __first, _InputIterator __last);
 
     _LIBCPP_INLINE_VISIBILITY
@@ -927,7 +929,7 @@ hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_multimap(
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 template <class _InputIterator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
                                                             _InputIterator __last)
diff --git a/include/ext/hash_set b/include/ext/hash_set
index c4bb89843d55..91850b566d5b 100644
--- a/include/ext/hash_set
+++ b/include/ext/hash_set
@@ -282,6 +282,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     iterator insert(const_iterator, const value_type& __x) {return insert(__x).first;}
     template <class _InputIterator>
+        _LIBCPP_INLINE_VISIBILITY
         void insert(_InputIterator __first, _InputIterator __last);
 
     _LIBCPP_INLINE_VISIBILITY
@@ -385,7 +386,7 @@ hash_set<_Value, _Hash, _Pred, _Alloc>::hash_set(
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 template <class _InputIterator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 hash_set<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
                                                     _InputIterator __last)
@@ -502,6 +503,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     iterator insert(const_iterator, const value_type& __x) {return insert(__x);}
     template <class _InputIterator>
+        _LIBCPP_INLINE_VISIBILITY
         void insert(_InputIterator __first, _InputIterator __last);
 
     _LIBCPP_INLINE_VISIBILITY
@@ -606,7 +608,7 @@ hash_multiset<_Value, _Hash, _Pred, _Alloc>::hash_multiset(
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 template <class _InputIterator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 hash_multiset<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
                                                          _InputIterator __last)
diff --git a/include/forward_list b/include/forward_list
index 4f9ecf49bd58..18b300d84703 100644
--- a/include/forward_list
+++ b/include/forward_list
@@ -183,15 +183,69 @@ template <class T, class Allocator>
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp, class _VoidPtr> struct __forward_list_node;
+template <class _NodePtr> struct __forward_begin_node;
+
+
+template <class>
+struct __forward_list_node_value_type;
+
+template <class _Tp, class _VoidPtr>
+struct __forward_list_node_value_type<__forward_list_node<_Tp, _VoidPtr> > {
+  typedef _Tp type;
+};
+
+template <class _NodePtr>
+struct __forward_node_traits {
+
+  typedef typename remove_cv<
+        typename pointer_traits<_NodePtr>::element_type>::type  __node;
+  typedef typename __forward_list_node_value_type<__node>::type __node_value_type;
+  typedef _NodePtr                                              __node_pointer;
+  typedef __forward_begin_node<_NodePtr>                        __begin_node;
+  typedef typename __rebind_pointer<_NodePtr, __begin_node>::type
+                                                                __begin_node_pointer;
+  typedef typename __rebind_pointer<_NodePtr, void>::type       __void_pointer;
+
+#if defined(_LIBCPP_ABI_FORWARD_LIST_REMOVE_NODE_POINTER_UB)
+  typedef __begin_node_pointer __iter_node_pointer;
+#else
+  typedef typename conditional<
+          is_pointer<__void_pointer>::value,
+          __begin_node_pointer,
+          __node_pointer
+    >::type __iter_node_pointer;
+#endif
+
+  typedef typename conditional<
+          is_same<__iter_node_pointer, __node_pointer>::value,
+          __begin_node_pointer,
+          __node_pointer
+    >::type __non_iter_node_pointer;
+
+  _LIBCPP_INLINE_VISIBILITY
+  static __iter_node_pointer __as_iter_node(__iter_node_pointer __p) {
+      return __p;
+  }
+  _LIBCPP_INLINE_VISIBILITY
+  static __iter_node_pointer __as_iter_node(__non_iter_node_pointer __p) {
+      return static_cast<__iter_node_pointer>(static_cast<__void_pointer>(__p));
+  }
+};
 
 template <class _NodePtr>
 struct __forward_begin_node
 {
     typedef _NodePtr pointer;
+    typedef typename __rebind_pointer<_NodePtr, __forward_begin_node>::type __begin_node_pointer;
 
     pointer __next_;
 
-     _LIBCPP_INLINE_VISIBILITY __forward_begin_node() : __next_(nullptr) {}
+    _LIBCPP_INLINE_VISIBILITY __forward_begin_node() : __next_(nullptr) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    __begin_node_pointer __next_as_begin() const {
+        return static_cast<__begin_node_pointer>(__next_);
+    }
 };
 
 template <class _Tp, class _VoidPtr>
@@ -211,26 +265,49 @@ struct __forward_list_node
     value_type __value_;
 };
 
+
 template <class _Tp, class _Alloc = allocator<_Tp> > class _LIBCPP_TYPE_VIS_ONLY forward_list;
 template<class _NodeConstPtr> class _LIBCPP_TYPE_VIS_ONLY __forward_list_const_iterator;
 
 template <class _NodePtr>
 class _LIBCPP_TYPE_VIS_ONLY __forward_list_iterator
 {
-    typedef _NodePtr __node_pointer;
+    typedef __forward_node_traits<_NodePtr>         __traits;
+    typedef typename __traits::__node_pointer       __node_pointer;
+    typedef typename __traits::__begin_node_pointer __begin_node_pointer;
+    typedef typename __traits::__iter_node_pointer  __iter_node_pointer;
+    typedef typename __traits::__void_pointer       __void_pointer;
 
-    __node_pointer __ptr_;
+    __iter_node_pointer __ptr_;
+
+    _LIBCPP_INLINE_VISIBILITY
+    __begin_node_pointer __get_begin() const {
+        return static_cast<__begin_node_pointer>(
+                static_cast<__void_pointer>(__ptr_));
+    }
+    _LIBCPP_INLINE_VISIBILITY
+    __node_pointer __get_unsafe_node_pointer() const {
+        return static_cast<__node_pointer>(
+                static_cast<__void_pointer>(__ptr_));
+    }
 
     _LIBCPP_INLINE_VISIBILITY
-    explicit __forward_list_iterator(__node_pointer __p) _NOEXCEPT : __ptr_(__p) {}
+    explicit __forward_list_iterator(nullptr_t) _NOEXCEPT : __ptr_(nullptr) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit __forward_list_iterator(__begin_node_pointer __p) _NOEXCEPT
+        : __ptr_(__traits::__as_iter_node(__p)) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit __forward_list_iterator(__node_pointer __p) _NOEXCEPT
+        : __ptr_(__traits::__as_iter_node(__p)) {}
 
     template<class, class> friend class _LIBCPP_TYPE_VIS_ONLY forward_list;
     template<class> friend class _LIBCPP_TYPE_VIS_ONLY __forward_list_const_iterator;
 
 public:
     typedef forward_iterator_tag                              iterator_category;
-    typedef typename pointer_traits<__node_pointer>::element_type::value_type
-                                                              value_type;
+    typedef typename __traits::__node_value_type              value_type;
     typedef value_type&                                       reference;
     typedef typename pointer_traits<__node_pointer>::difference_type
                                                               difference_type;
@@ -240,14 +317,16 @@ public:
     __forward_list_iterator() _NOEXCEPT : __ptr_(nullptr) {}
 
     _LIBCPP_INLINE_VISIBILITY
-    reference operator*() const {return __ptr_->__value_;}
+    reference operator*() const {return __get_unsafe_node_pointer()->__value_;}
     _LIBCPP_INLINE_VISIBILITY
-    pointer operator->() const {return pointer_traits<pointer>::pointer_to(__ptr_->__value_);}
+    pointer operator->() const {
+        return pointer_traits<pointer>::pointer_to(__get_unsafe_node_pointer()->__value_);
+    }
 
     _LIBCPP_INLINE_VISIBILITY
     __forward_list_iterator& operator++()
     {
-        __ptr_ = __ptr_->__next_;
+        __ptr_ = __traits::__as_iter_node(__ptr_->__next_);
         return *this;
     }
     _LIBCPP_INLINE_VISIBILITY
@@ -271,29 +350,50 @@ public:
 template <class _NodeConstPtr>
 class _LIBCPP_TYPE_VIS_ONLY __forward_list_const_iterator
 {
-    typedef _NodeConstPtr __node_const_pointer;
+    static_assert((!is_const<typename pointer_traits<_NodeConstPtr>::element_type>::value), "");
+    typedef _NodeConstPtr _NodePtr;
+
+    typedef __forward_node_traits<_NodePtr>         __traits;
+    typedef typename __traits::__node               __node;
+    typedef typename __traits::__node_pointer       __node_pointer;
+    typedef typename __traits::__begin_node_pointer __begin_node_pointer;
+    typedef typename __traits::__iter_node_pointer  __iter_node_pointer;
+    typedef typename __traits::__void_pointer       __void_pointer;
 
-    __node_const_pointer __ptr_;
+    __iter_node_pointer __ptr_;
+
+    __begin_node_pointer __get_begin() const {
+        return static_cast<__begin_node_pointer>(
+                static_cast<__void_pointer>(__ptr_));
+    }
+    __node_pointer __get_unsafe_node_pointer() const {
+        return static_cast<__node_pointer>(
+                static_cast<__void_pointer>(__ptr_));
+    }
 
     _LIBCPP_INLINE_VISIBILITY
-    explicit __forward_list_const_iterator(__node_const_pointer __p) _NOEXCEPT
-        : __ptr_(__p) {}
+    explicit __forward_list_const_iterator(nullptr_t) _NOEXCEPT
+        : __ptr_(nullptr) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit __forward_list_const_iterator(__begin_node_pointer __p) _NOEXCEPT
+        : __ptr_(__traits::__as_iter_node(__p)) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit __forward_list_const_iterator(__node_pointer __p) _NOEXCEPT
+        : __ptr_(__traits::__as_iter_node(__p)) {}
 
-    typedef typename remove_const
-        <
-            typename pointer_traits<__node_const_pointer>::element_type
-        >::type                                               __node;
-    typedef typename __rebind_pointer<__node_const_pointer, __node>::type __node_pointer;
 
     template<class, class> friend class forward_list;
 
 public:
     typedef forward_iterator_tag                              iterator_category;
-    typedef typename __node::value_type                       value_type;
+    typedef typename __traits::__node_value_type              value_type;
     typedef const value_type&                                 reference;
-    typedef typename pointer_traits<__node_const_pointer>::difference_type
+    typedef typename pointer_traits<__node_pointer>::difference_type
                                                               difference_type;
-    typedef typename __rebind_pointer<__node_const_pointer, const value_type>::type pointer;
+    typedef typename __rebind_pointer<__node_pointer, const value_type>::type
+                                                              pointer;
 
     _LIBCPP_INLINE_VISIBILITY
     __forward_list_const_iterator() _NOEXCEPT : __ptr_(nullptr) {}
@@ -302,14 +402,15 @@ public:
         : __ptr_(__p.__ptr_) {}
 
     _LIBCPP_INLINE_VISIBILITY
-    reference operator*() const {return __ptr_->__value_;}
+    reference operator*() const {return __get_unsafe_node_pointer()->__value_;}
     _LIBCPP_INLINE_VISIBILITY
-    pointer operator->() const {return pointer_traits<pointer>::pointer_to(__ptr_->__value_);}
+    pointer operator->() const {return pointer_traits<pointer>::pointer_to(
+                __get_unsafe_node_pointer()->__value_);}
 
     _LIBCPP_INLINE_VISIBILITY
     __forward_list_const_iterator& operator++()
     {
-        __ptr_ = __ptr_->__next_;
+        __ptr_ = __traits::__as_iter_node(__ptr_->__next_);
         return *this;
     }
     _LIBCPP_INLINE_VISIBILITY
@@ -343,21 +444,21 @@ protected:
     typedef typename __rebind_alloc_helper<allocator_traits<allocator_type>, __node>::type __node_allocator;
     typedef allocator_traits<__node_allocator>        __node_traits;
     typedef typename __node_traits::pointer           __node_pointer;
-    typedef typename __node_traits::pointer           __node_const_pointer;
 
-    typedef typename __rebind_alloc_helper<allocator_traits<allocator_type>, __begin_node>::type __begin_node_allocator;
-    typedef typename allocator_traits<__begin_node_allocator>::pointer __begin_node_pointer;
+    typedef typename __rebind_alloc_helper<
+        allocator_traits<allocator_type>, __begin_node
+    >::type                                           __begin_node_allocator;
+    typedef typename allocator_traits<__begin_node_allocator>::pointer
+                                                      __begin_node_pointer;
 
     __compressed_pair<__begin_node, __node_allocator> __before_begin_;
 
     _LIBCPP_INLINE_VISIBILITY
-    __node_pointer        __before_begin() _NOEXCEPT
-        {return static_cast<__node_pointer>(pointer_traits<__begin_node_pointer>::
-                                        pointer_to(__before_begin_.first()));}
+    __begin_node_pointer        __before_begin() _NOEXCEPT
+        {return pointer_traits<__begin_node_pointer>::pointer_to(__before_begin_.first());}
     _LIBCPP_INLINE_VISIBILITY
-    __node_const_pointer  __before_begin() const _NOEXCEPT
-        {return static_cast<__node_const_pointer>(pointer_traits<__begin_node_pointer>::
-                                        pointer_to(const_cast<__begin_node&>(__before_begin_.first())));}
+    __begin_node_pointer __before_begin() const _NOEXCEPT
+        {return pointer_traits<__begin_node_pointer>::pointer_to(const_cast<__begin_node&>(__before_begin_.first()));}
 
     _LIBCPP_INLINE_VISIBILITY
           __node_allocator& __alloc() _NOEXCEPT
@@ -379,8 +480,10 @@ protected:
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 public:
+    _LIBCPP_INLINE_VISIBILITY
     __forward_list_base(__forward_list_base&& __x)
         _NOEXCEPT_(is_nothrow_move_constructible<__node_allocator>::value);
+    _LIBCPP_INLINE_VISIBILITY
     __forward_list_base(__forward_list_base&& __x, const allocator_type& __a);
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
@@ -405,6 +508,7 @@ protected:
               __node_traits::propagate_on_container_move_assignment::value>());}
 
 public:
+    _LIBCPP_INLINE_VISIBILITY
     void swap(__forward_list_base& __x)
 #if _LIBCPP_STD_VER >= 14
         _NOEXCEPT;
@@ -438,7 +542,7 @@ private:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 __forward_list_base<_Tp, _Alloc>::__forward_list_base(__forward_list_base&& __x)
         _NOEXCEPT_(is_nothrow_move_constructible<__node_allocator>::value)
     : __before_begin_(_VSTD::move(__x.__before_begin_))
@@ -447,7 +551,7 @@ __forward_list_base<_Tp, _Alloc>::__forward_list_base(__forward_list_base&& __x)
 }
 
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 __forward_list_base<_Tp, _Alloc>::__forward_list_base(__forward_list_base&& __x,
                                                       const allocator_type& __a)
     : __before_begin_(__begin_node(), __node_allocator(__a))
@@ -468,7 +572,7 @@ __forward_list_base<_Tp, _Alloc>::~__forward_list_base()
 }
 
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 __forward_list_base<_Tp, _Alloc>::swap(__forward_list_base& __x)
 #if _LIBCPP_STD_VER >= 14
@@ -505,9 +609,10 @@ class _LIBCPP_TYPE_VIS_ONLY forward_list
 {
     typedef __forward_list_base<_Tp, _Alloc> base;
     typedef typename base::__node_allocator  __node_allocator;
-    typedef typename base::__node            __node;
-    typedef typename base::__node_traits     __node_traits;
-    typedef typename base::__node_pointer    __node_pointer;
+    typedef typename base::__node               __node;
+    typedef typename base::__node_traits        __node_traits;
+    typedef typename base::__node_pointer       __node_pointer;
+    typedef typename base::__begin_node_pointer __begin_node_pointer;
 
 public:
     typedef _Tp    value_type;
@@ -530,6 +635,7 @@ public:
     forward_list()
         _NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value)
         {} // = default;
+    _LIBCPP_INLINE_VISIBILITY
     explicit forward_list(const allocator_type& __a);
     explicit forward_list(size_type __n);
 #if _LIBCPP_STD_VER > 11
@@ -566,12 +672,14 @@ public:
 
     forward_list& operator=(const forward_list& __x);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     forward_list& operator=(forward_list&& __x)
         _NOEXCEPT_(
              __node_traits::propagate_on_container_move_assignment::value &&
              is_nothrow_move_assignable<allocator_type>::value);
 #endif
 #ifndef  _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+    _LIBCPP_INLINE_VISIBILITY
     forward_list& operator=(initializer_list<value_type> __il);
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
@@ -584,6 +692,7 @@ public:
         assign(_InputIterator __f, _InputIterator __l);
     void assign(size_type __n, const value_type& __v);
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+    _LIBCPP_INLINE_VISIBILITY
     void assign(initializer_list<value_type> __il);
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
@@ -714,7 +823,7 @@ public:
     template <class _Compare> void merge(forward_list& __x, _Compare __comp);
     _LIBCPP_INLINE_VISIBILITY
     void sort() {sort(__less<value_type>());}
-    template <class _Compare> void sort(_Compare __comp);
+    template <class _Compare> _LIBCPP_INLINE_VISIBILITY void sort(_Compare __comp);
     void reverse() _NOEXCEPT;
 
 private:
@@ -737,7 +846,7 @@ private:
 };
 
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 forward_list<_Tp, _Alloc>::forward_list(const allocator_type& __a)
     : base(__a)
 {
@@ -751,8 +860,8 @@ forward_list<_Tp, _Alloc>::forward_list(size_type __n)
         __node_allocator& __a = base::__alloc();
         typedef __allocator_destructor<__node_allocator> _Dp;
         unique_ptr<__node, _Dp> __h(nullptr, _Dp(__a, 1));
-        for (__node_pointer __p = base::__before_begin(); __n > 0; --__n,
-                                                             __p = __p->__next_)
+        for (__begin_node_pointer __p = base::__before_begin(); __n > 0; --__n,
+                                                             __p = __p->__next_as_begin())
         {
             __h.reset(__node_traits::allocate(__a, 1));
             __node_traits::construct(__a, _VSTD::addressof(__h->__value_));
@@ -772,8 +881,8 @@ forward_list<_Tp, _Alloc>::forward_list(size_type __n, const allocator_type& __a
         __node_allocator& __a = base::__alloc();
         typedef __allocator_destructor<__node_allocator> _Dp;
         unique_ptr<__node, _Dp> __h(nullptr, _Dp(__a, 1));
-        for (__node_pointer __p = base::__before_begin(); __n > 0; --__n,
-                                                             __p = __p->__next_)
+        for (__begin_node_pointer __p = base::__before_begin(); __n > 0; --__n,
+                                                             __p = __p->__next_as_begin())
         {
             __h.reset(__node_traits::allocate(__a, 1));
             __node_traits::construct(__a, _VSTD::addressof(__h->__value_));
@@ -911,7 +1020,7 @@ forward_list<_Tp, _Alloc>::__move_assign(forward_list& __x, false_type)
 }
 
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 forward_list<_Tp, _Alloc>&
 forward_list<_Tp, _Alloc>::operator=(forward_list&& __x)
     _NOEXCEPT_(
@@ -928,7 +1037,7 @@ forward_list<_Tp, _Alloc>::operator=(forward_list&& __x)
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 forward_list<_Tp, _Alloc>&
 forward_list<_Tp, _Alloc>::operator=(initializer_list<value_type> __il)
 {
@@ -976,7 +1085,7 @@ forward_list<_Tp, _Alloc>::assign(size_type __n, const value_type& __v)
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 forward_list<_Tp, _Alloc>::assign(initializer_list<value_type> __il)
 {
@@ -1049,7 +1158,7 @@ template <class... _Args>
 typename forward_list<_Tp, _Alloc>::iterator
 forward_list<_Tp, _Alloc>::emplace_after(const_iterator __p, _Args&&... __args)
 {
-    __node_pointer const __r = __p.__ptr_;
+    __begin_node_pointer const __r = __p.__get_begin();
     __node_allocator& __a = base::__alloc();
     typedef __allocator_destructor<__node_allocator> _Dp;
     unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
@@ -1066,7 +1175,7 @@ template <class _Tp, class _Alloc>
 typename forward_list<_Tp, _Alloc>::iterator
 forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, value_type&& __v)
 {
-    __node_pointer const __r = __p.__ptr_;
+    __begin_node_pointer const __r = __p.__get_begin();
     __node_allocator& __a = base::__alloc();
     typedef __allocator_destructor<__node_allocator> _Dp;
     unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
@@ -1082,7 +1191,7 @@ template <class _Tp, class _Alloc>
 typename forward_list<_Tp, _Alloc>::iterator
 forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, const value_type& __v)
 {
-    __node_pointer const __r = __p.__ptr_;
+    __begin_node_pointer const __r = __p.__get_begin();
     __node_allocator& __a = base::__alloc();
     typedef __allocator_destructor<__node_allocator> _Dp;
     unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
@@ -1097,7 +1206,7 @@ typename forward_list<_Tp, _Alloc>::iterator
 forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, size_type __n,
                                         const value_type& __v)
 {
-    __node_pointer __r = __p.__ptr_;
+    __begin_node_pointer __r = __p.__get_begin();
     if (__n > 0)
     {
         __node_allocator& __a = base::__alloc();
@@ -1132,7 +1241,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, size_type __n,
 #endif  // _LIBCPP_NO_EXCEPTIONS
         __last->__next_ = __r->__next_;
         __r->__next_ = __first;
-        __r = __last;
+        __r = static_cast<__begin_node_pointer>(__last);
     }
     return iterator(__r);
 }
@@ -1147,7 +1256,7 @@ typename enable_if
 forward_list<_Tp, _Alloc>::insert_after(const_iterator __p,
                                         _InputIterator __f, _InputIterator __l)
 {
-    __node_pointer __r = __p.__ptr_;
+    __begin_node_pointer __r = __p.__get_begin();
     if (__f != __l)
     {
         __node_allocator& __a = base::__alloc();
@@ -1182,7 +1291,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p,
 #endif  // _LIBCPP_NO_EXCEPTIONS
         __last->__next_ = __r->__next_;
         __r->__next_ = __first;
-        __r = __last;
+        __r = static_cast<__begin_node_pointer>(__last);
     }
     return iterator(__r);
 }
@@ -1191,7 +1300,7 @@ template <class _Tp, class _Alloc>
 typename forward_list<_Tp, _Alloc>::iterator
 forward_list<_Tp, _Alloc>::erase_after(const_iterator __f)
 {
-    __node_pointer __p = __f.__ptr_;
+    __begin_node_pointer __p = __f.__get_begin();
     __node_pointer __n = __p->__next_;
     __p->__next_ = __n->__next_;
     __node_allocator& __a = base::__alloc();
@@ -1204,21 +1313,22 @@ template <class _Tp, class _Alloc>
 typename forward_list<_Tp, _Alloc>::iterator
 forward_list<_Tp, _Alloc>::erase_after(const_iterator __f, const_iterator __l)
 {
-    __node_pointer __e = __l.__ptr_;
+    __node_pointer __e = __l.__get_unsafe_node_pointer();
     if (__f != __l)
     {
-        __node_pointer __p = __f.__ptr_;
-        __node_pointer __n = __p->__next_;
+        __begin_node_pointer __bp = __f.__get_begin();
+
+        __node_pointer __n = __bp->__next_;
         if (__n != __e)
         {
-            __p->__next_ = __e;
+            __bp->__next_ = __e;
             __node_allocator& __a = base::__alloc();
             do
             {
-                __p = __n->__next_;
+                __node_pointer __tmp = __n->__next_;
                 __node_traits::destroy(__a, _VSTD::addressof(__n->__value_));
                 __node_traits::deallocate(__a, __n, 1);
-                __n = __p;
+                __n = __tmp;
             } while (__n != __e);
         }
     }
@@ -1245,8 +1355,8 @@ forward_list<_Tp, _Alloc>::resize(size_type __n)
             __node_allocator& __a = base::__alloc();
             typedef __allocator_destructor<__node_allocator> _Dp;
             unique_ptr<__node, _Dp> __h(nullptr, _Dp(__a, 1));
-            for (__node_pointer __ptr = __p.__ptr_; __n > 0; --__n,
-                                                         __ptr = __ptr->__next_)
+            for (__begin_node_pointer __ptr = __p.__get_begin(); __n > 0; --__n,
+                                                         __ptr = __ptr->__next_as_begin())
             {
                 __h.reset(__node_traits::allocate(__a, 1));
                 __node_traits::construct(__a, _VSTD::addressof(__h->__value_));
@@ -1277,8 +1387,8 @@ forward_list<_Tp, _Alloc>::resize(size_type __n, const value_type& __v)
             __node_allocator& __a = base::__alloc();
             typedef __allocator_destructor<__node_allocator> _Dp;
             unique_ptr<__node, _Dp> __h(nullptr, _Dp(__a, 1));
-            for (__node_pointer __ptr = __p.__ptr_; __n > 0; --__n,
-                                                         __ptr = __ptr->__next_)
+            for (__begin_node_pointer __ptr = __p.__get_begin(); __n > 0; --__n,
+                                                         __ptr = __ptr->__next_as_begin())
             {
                 __h.reset(__node_traits::allocate(__a, 1));
                 __node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v);
@@ -1296,14 +1406,14 @@ forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
 {
     if (!__x.empty())
     {
-        if (__p.__ptr_->__next_ != nullptr)
+        if (__p.__get_begin()->__next_ != nullptr)
         {
             const_iterator __lm1 = __x.before_begin();
-            while (__lm1.__ptr_->__next_ != nullptr)
+            while (__lm1.__get_begin()->__next_ != nullptr)
                 ++__lm1;
-            __lm1.__ptr_->__next_ = __p.__ptr_->__next_;
+            __lm1.__get_begin()->__next_ = __p.__get_begin()->__next_;
         }
-        __p.__ptr_->__next_ = __x.__before_begin()->__next_;
+        __p.__get_begin()->__next_ = __x.__before_begin()->__next_;
         __x.__before_begin()->__next_ = nullptr;
     }
 }
@@ -1317,9 +1427,9 @@ forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
     const_iterator __lm1 = _VSTD::next(__i);
     if (__p != __i && __p != __lm1)
     {
-        __i.__ptr_->__next_ = __lm1.__ptr_->__next_;
-        __lm1.__ptr_->__next_ = __p.__ptr_->__next_;
-        __p.__ptr_->__next_ = __lm1.__ptr_;
+        __i.__get_begin()->__next_ = __lm1.__get_begin()->__next_;
+        __lm1.__get_begin()->__next_ = __p.__get_begin()->__next_;
+        __p.__get_begin()->__next_ = __lm1.__get_unsafe_node_pointer();
     }
 }
 
@@ -1332,13 +1442,13 @@ forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
     if (__f != __l && __p != __f)
     {
         const_iterator __lm1 = __f;
-        while (__lm1.__ptr_->__next_ != __l.__ptr_)
+        while (__lm1.__get_begin()->__next_ != __l.__get_begin())
             ++__lm1;
         if (__f != __lm1)
         {
-            __lm1.__ptr_->__next_ = __p.__ptr_->__next_;
-            __p.__ptr_->__next_ = __f.__ptr_->__next_;
-            __f.__ptr_->__next_ = __l.__ptr_;
+            __lm1.__get_begin()->__next_ = __p.__get_begin()->__next_;
+            __p.__get_begin()->__next_ = __f.__get_begin()->__next_;
+            __f.__get_begin()->__next_ = __l.__get_unsafe_node_pointer();
         }
     }
 }
@@ -1382,9 +1492,9 @@ forward_list<_Tp, _Alloc>::remove(const value_type& __v)
 {
     forward_list<_Tp, _Alloc> __deleted_nodes; // collect the nodes we're removing
     iterator __e = end();
-    for (iterator __i = before_begin(); __i.__ptr_->__next_ != nullptr;)
+    for (iterator __i = before_begin(); __i.__get_begin()->__next_ != nullptr;)
     {
-        if (__i.__ptr_->__next_->__value_ == __v)
+        if (__i.__get_begin()->__next_->__value_ == __v)
         {
             iterator __j = _VSTD::next(__i, 2);
             for (; __j != __e && *__j == __v; ++__j)
@@ -1405,9 +1515,9 @@ void
 forward_list<_Tp, _Alloc>::remove_if(_Predicate __pred)
 {
     iterator __e = end();
-    for (iterator __i = before_begin(); __i.__ptr_->__next_ != nullptr;)
+    for (iterator __i = before_begin(); __i.__get_begin()->__next_ != nullptr;)
     {
-        if (__pred(__i.__ptr_->__next_->__value_))
+        if (__pred(__i.__get_begin()->__next_->__value_))
         {
             iterator __j = _VSTD::next(__i, 2);
             for (; __j != __e && __pred(*__j); ++__j)
@@ -1432,7 +1542,7 @@ forward_list<_Tp, _Alloc>::unique(_BinaryPredicate __binary_pred)
         iterator __j = _VSTD::next(__i);
         for (; __j != __e && __binary_pred(*__i, *__j); ++__j)
             ;
-        if (__i.__ptr_->__next_ != __j.__ptr_)
+        if (__i.__get_begin()->__next_ != __j.__get_unsafe_node_pointer())
             erase_after(__i, __j);
         __i = __j;
     }
@@ -1499,7 +1609,7 @@ forward_list<_Tp, _Alloc>::__merge(__node_pointer __f1, __node_pointer __f2,
 
 template <class _Tp, class _Alloc>
 template <class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 forward_list<_Tp, _Alloc>::sort(_Compare __comp)
 {
@@ -1530,7 +1640,7 @@ forward_list<_Tp, _Alloc>::__sort(__node_pointer __f1, difference_type __sz,
     }
     difference_type __sz1 = __sz / 2;
     difference_type __sz2 = __sz - __sz1;
-    __node_pointer __t = _VSTD::next(iterator(__f1), __sz1 - 1).__ptr_;
+    __node_pointer __t = _VSTD::next(iterator(__f1), __sz1 - 1).__get_unsafe_node_pointer();
     __node_pointer __f2 = __t->__next_;
     __t->__next_ = nullptr;
     return __merge(__sort(__f1, __sz1, __comp),
diff --git a/include/fstream b/include/fstream
index 1f289eddc56f..3cb3b13bd10f 100644
--- a/include/fstream
+++ b/include/fstream
@@ -200,14 +200,17 @@ public:
 
     // 27.9.1.3 Assign/swap:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     basic_filebuf& operator=(basic_filebuf&& __rhs);
 #endif
     void swap(basic_filebuf& __rhs);
 
     // 27.9.1.4 Members:
+    _LIBCPP_INLINE_VISIBILITY
     bool is_open() const;
 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
     basic_filebuf* open(const char* __s, ios_base::openmode __mode);
+    _LIBCPP_INLINE_VISIBILITY
     basic_filebuf* open(const string& __s, ios_base::openmode __mode);
 #endif
     basic_filebuf* close();
@@ -340,7 +343,7 @@ basic_filebuf<_CharT, _Traits>::basic_filebuf(basic_filebuf&& __rhs)
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_filebuf<_CharT, _Traits>&
 basic_filebuf<_CharT, _Traits>::operator=(basic_filebuf&& __rhs)
 {
@@ -458,7 +461,7 @@ swap(basic_filebuf<_CharT, _Traits>& __x, basic_filebuf<_CharT, _Traits>& __y)
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 basic_filebuf<_CharT, _Traits>::is_open() const
 {
@@ -547,7 +550,7 @@ basic_filebuf<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode)
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_filebuf<_CharT, _Traits>*
 basic_filebuf<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode)
 {
@@ -603,7 +606,9 @@ basic_filebuf<_CharT, _Traits>::underflow()
         }
         else
         {
-            memmove(__extbuf_, __extbufnext_, __extbufend_ - __extbufnext_);
+            _LIBCPP_ASSERT ( !(__extbufnext_ == NULL && (__extbufend_ != __extbufnext_)), "underflow moving from NULL" );
+            if (__extbufend_ != __extbufnext_)
+                memmove(__extbuf_, __extbufnext_, __extbufend_ - __extbufnext_);
             __extbufnext_ = __extbuf_ + (__extbufend_ - __extbufnext_);
             __extbufend_ = __extbuf_ + (__extbuf_ == __extbuf_min_ ? sizeof(__extbuf_min_) : __ebs_);
             size_t __nmemb = _VSTD::min(static_cast<size_t>(__ibs_ - __unget_sz),
@@ -1008,26 +1013,35 @@ public:
     typedef typename traits_type::pos_type pos_type;
     typedef typename traits_type::off_type off_type;
 
+    _LIBCPP_INLINE_VISIBILITY
     basic_ifstream();
 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
+    _LIBCPP_INLINE_VISIBILITY
     explicit basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in);
+    _LIBCPP_INLINE_VISIBILITY
     explicit basic_ifstream(const string& __s, ios_base::openmode __mode = ios_base::in);
 #endif
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     basic_ifstream(basic_ifstream&& __rhs);
 #endif
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     basic_ifstream& operator=(basic_ifstream&& __rhs);
 #endif
+    _LIBCPP_INLINE_VISIBILITY
     void swap(basic_ifstream& __rhs);
 
+    _LIBCPP_INLINE_VISIBILITY
     basic_filebuf<char_type, traits_type>* rdbuf() const;
+    _LIBCPP_INLINE_VISIBILITY
     bool is_open() const;
 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
     void open(const char* __s, ios_base::openmode __mode = ios_base::in);
     void open(const string& __s, ios_base::openmode __mode = ios_base::in);
 #endif
+    _LIBCPP_INLINE_VISIBILITY
     void close();
 
 private:
@@ -1035,7 +1049,7 @@ private:
 };
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_ifstream<_CharT, _Traits>::basic_ifstream()
     : basic_istream<char_type, traits_type>(&__sb_)
 {
@@ -1043,7 +1057,7 @@ basic_ifstream<_CharT, _Traits>::basic_ifstream()
 
 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_ifstream<_CharT, _Traits>::basic_ifstream(const char* __s, ios_base::openmode __mode)
     : basic_istream<char_type, traits_type>(&__sb_)
 {
@@ -1052,7 +1066,7 @@ basic_ifstream<_CharT, _Traits>::basic_ifstream(const char* __s, ios_base::openm
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_ifstream<_CharT, _Traits>::basic_ifstream(const string& __s, ios_base::openmode __mode)
     : basic_istream<char_type, traits_type>(&__sb_)
 {
@@ -1064,7 +1078,7 @@ basic_ifstream<_CharT, _Traits>::basic_ifstream(const string& __s, ios_base::ope
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_ifstream<_CharT, _Traits>::basic_ifstream(basic_ifstream&& __rhs)
     : basic_istream<char_type, traits_type>(_VSTD::move(__rhs)),
       __sb_(_VSTD::move(__rhs.__sb_))
@@ -1073,7 +1087,7 @@ basic_ifstream<_CharT, _Traits>::basic_ifstream(basic_ifstream&& __rhs)
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_ifstream<_CharT, _Traits>&
 basic_ifstream<_CharT, _Traits>::operator=(basic_ifstream&& __rhs)
 {
@@ -1085,7 +1099,7 @@ basic_ifstream<_CharT, _Traits>::operator=(basic_ifstream&& __rhs)
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 basic_ifstream<_CharT, _Traits>::swap(basic_ifstream& __rhs)
 {
@@ -1102,7 +1116,7 @@ swap(basic_ifstream<_CharT, _Traits>& __x, basic_ifstream<_CharT, _Traits>& __y)
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_filebuf<_CharT, _Traits>*
 basic_ifstream<_CharT, _Traits>::rdbuf() const
 {
@@ -1110,7 +1124,7 @@ basic_ifstream<_CharT, _Traits>::rdbuf() const
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 basic_ifstream<_CharT, _Traits>::is_open() const
 {
@@ -1140,7 +1154,7 @@ basic_ifstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mo
 #endif
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 basic_ifstream<_CharT, _Traits>::close()
 {
@@ -1161,24 +1175,33 @@ public:
     typedef typename traits_type::pos_type pos_type;
     typedef typename traits_type::off_type off_type;
 
+    _LIBCPP_INLINE_VISIBILITY
     basic_ofstream();
+    _LIBCPP_INLINE_VISIBILITY
     explicit basic_ofstream(const char* __s, ios_base::openmode __mode = ios_base::out);
+    _LIBCPP_INLINE_VISIBILITY
     explicit basic_ofstream(const string& __s, ios_base::openmode __mode = ios_base::out);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     basic_ofstream(basic_ofstream&& __rhs);
 #endif
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     basic_ofstream& operator=(basic_ofstream&& __rhs);
 #endif
+    _LIBCPP_INLINE_VISIBILITY
     void swap(basic_ofstream& __rhs);
 
+    _LIBCPP_INLINE_VISIBILITY
     basic_filebuf<char_type, traits_type>* rdbuf() const;
+    _LIBCPP_INLINE_VISIBILITY
     bool is_open() const;
 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
     void open(const char* __s, ios_base::openmode __mode = ios_base::out);
     void open(const string& __s, ios_base::openmode __mode = ios_base::out);
 #endif
+    _LIBCPP_INLINE_VISIBILITY
     void close();
 
 private:
@@ -1186,7 +1209,7 @@ private:
 };
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_ofstream<_CharT, _Traits>::basic_ofstream()
     : basic_ostream<char_type, traits_type>(&__sb_)
 {
@@ -1194,7 +1217,7 @@ basic_ofstream<_CharT, _Traits>::basic_ofstream()
 
 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_ofstream<_CharT, _Traits>::basic_ofstream(const char* __s, ios_base::openmode __mode)
     : basic_ostream<char_type, traits_type>(&__sb_)
 {
@@ -1203,7 +1226,7 @@ basic_ofstream<_CharT, _Traits>::basic_ofstream(const char* __s, ios_base::openm
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_ofstream<_CharT, _Traits>::basic_ofstream(const string& __s, ios_base::openmode __mode)
     : basic_ostream<char_type, traits_type>(&__sb_)
 {
@@ -1215,7 +1238,7 @@ basic_ofstream<_CharT, _Traits>::basic_ofstream(const string& __s, ios_base::ope
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_ofstream<_CharT, _Traits>::basic_ofstream(basic_ofstream&& __rhs)
     : basic_ostream<char_type, traits_type>(_VSTD::move(__rhs)),
       __sb_(_VSTD::move(__rhs.__sb_))
@@ -1224,7 +1247,7 @@ basic_ofstream<_CharT, _Traits>::basic_ofstream(basic_ofstream&& __rhs)
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_ofstream<_CharT, _Traits>&
 basic_ofstream<_CharT, _Traits>::operator=(basic_ofstream&& __rhs)
 {
@@ -1236,7 +1259,7 @@ basic_ofstream<_CharT, _Traits>::operator=(basic_ofstream&& __rhs)
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 basic_ofstream<_CharT, _Traits>::swap(basic_ofstream& __rhs)
 {
@@ -1253,7 +1276,7 @@ swap(basic_ofstream<_CharT, _Traits>& __x, basic_ofstream<_CharT, _Traits>& __y)
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_filebuf<_CharT, _Traits>*
 basic_ofstream<_CharT, _Traits>::rdbuf() const
 {
@@ -1261,7 +1284,7 @@ basic_ofstream<_CharT, _Traits>::rdbuf() const
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 basic_ofstream<_CharT, _Traits>::is_open() const
 {
@@ -1291,7 +1314,7 @@ basic_ofstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mo
 #endif
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 basic_ofstream<_CharT, _Traits>::close()
 {
@@ -1312,26 +1335,35 @@ public:
     typedef typename traits_type::pos_type pos_type;
     typedef typename traits_type::off_type off_type;
 
+    _LIBCPP_INLINE_VISIBILITY
     basic_fstream();
 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
+    _LIBCPP_INLINE_VISIBILITY
     explicit basic_fstream(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
+    _LIBCPP_INLINE_VISIBILITY
     explicit basic_fstream(const string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
 #endif
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     basic_fstream(basic_fstream&& __rhs);
 #endif
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     basic_fstream& operator=(basic_fstream&& __rhs);
 #endif
+    _LIBCPP_INLINE_VISIBILITY
     void swap(basic_fstream& __rhs);
 
+    _LIBCPP_INLINE_VISIBILITY
     basic_filebuf<char_type, traits_type>* rdbuf() const;
+    _LIBCPP_INLINE_VISIBILITY
     bool is_open() const;
 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
     void open(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
     void open(const string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
 #endif
+    _LIBCPP_INLINE_VISIBILITY
     void close();
 
 private:
@@ -1339,7 +1371,7 @@ private:
 };
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_fstream<_CharT, _Traits>::basic_fstream()
     : basic_iostream<char_type, traits_type>(&__sb_)
 {
@@ -1347,7 +1379,7 @@ basic_fstream<_CharT, _Traits>::basic_fstream()
 
 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_fstream<_CharT, _Traits>::basic_fstream(const char* __s, ios_base::openmode __mode)
     : basic_iostream<char_type, traits_type>(&__sb_)
 {
@@ -1356,7 +1388,7 @@ basic_fstream<_CharT, _Traits>::basic_fstream(const char* __s, ios_base::openmod
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_fstream<_CharT, _Traits>::basic_fstream(const string& __s, ios_base::openmode __mode)
     : basic_iostream<char_type, traits_type>(&__sb_)
 {
@@ -1368,7 +1400,7 @@ basic_fstream<_CharT, _Traits>::basic_fstream(const string& __s, ios_base::openm
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_fstream<_CharT, _Traits>::basic_fstream(basic_fstream&& __rhs)
     : basic_iostream<char_type, traits_type>(_VSTD::move(__rhs)),
       __sb_(_VSTD::move(__rhs.__sb_))
@@ -1377,7 +1409,7 @@ basic_fstream<_CharT, _Traits>::basic_fstream(basic_fstream&& __rhs)
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_fstream<_CharT, _Traits>&
 basic_fstream<_CharT, _Traits>::operator=(basic_fstream&& __rhs)
 {
@@ -1389,7 +1421,7 @@ basic_fstream<_CharT, _Traits>::operator=(basic_fstream&& __rhs)
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 basic_fstream<_CharT, _Traits>::swap(basic_fstream& __rhs)
 {
@@ -1406,7 +1438,7 @@ swap(basic_fstream<_CharT, _Traits>& __x, basic_fstream<_CharT, _Traits>& __y)
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_filebuf<_CharT, _Traits>*
 basic_fstream<_CharT, _Traits>::rdbuf() const
 {
@@ -1414,7 +1446,7 @@ basic_fstream<_CharT, _Traits>::rdbuf() const
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 basic_fstream<_CharT, _Traits>::is_open() const
 {
@@ -1444,7 +1476,7 @@ basic_fstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mod
 #endif
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 basic_fstream<_CharT, _Traits>::close()
 {
diff --git a/include/functional b/include/functional
index dbe9b01bbd86..581f965b2b81 100644
--- a/include/functional
+++ b/include/functional
@@ -207,6 +207,8 @@ public:
 
 template <class Predicate> binary_negate<Predicate> not2(const Predicate& pred);
 
+template <class F> unspecified not_fn(F&& f); // C++17
+
 template<class T> struct is_bind_expression;
 template<class T> struct is_placeholder;
 
@@ -407,7 +409,7 @@ public:
     // function modifiers:
     void swap(function&) noexcept;
     template<class F, class Alloc>
-      void assign(F&&, const Alloc&);
+      void assign(F&&, const Alloc&);                 // Removed in C++17
 
     // function capacity:
     explicit operator bool() const noexcept;
@@ -1564,6 +1566,10 @@ class _LIBCPP_TYPE_VIS_ONLY function<_Rp(_ArgTypes...)>
     typename aligned_storage<3*sizeof(void*)>::type __buf_;
     __base* __f_;
 
+    _LIBCPP_NO_CFI static __base *__as_base(void *p) {
+      return reinterpret_cast<__base*>(p);
+    }
+
     template <class _Fp, bool = !is_same<_Fp, function>::value &&
                                 __invokable<_Fp&, _ArgTypes...>::value>
         struct __callable;
@@ -1626,10 +1632,13 @@ public:
 
     // function modifiers:
     void swap(function&) _NOEXCEPT;
+
+#if _LIBCPP_STD_VER <= 14
     template<class _Fp, class _Alloc>
       _LIBCPP_INLINE_VISIBILITY
       void assign(_Fp&& __f, const _Alloc& __a)
         {function(allocator_arg, __a, _VSTD::forward<_Fp>(__f)).swap(*this);}
+#endif
 
     // function capacity:
     _LIBCPP_INLINE_VISIBILITY
@@ -1657,9 +1666,9 @@ function<_Rp(_ArgTypes...)>::function(const function& __f)
 {
     if (__f.__f_ == 0)
         __f_ = 0;
-    else if (__f.__f_ == (const __base*)&__f.__buf_)
+    else if ((void *)__f.__f_ == &__f.__buf_)
     {
-        __f_ = (__base*)&__buf_;
+        __f_ = __as_base(&__buf_);
         __f.__f_->__clone(__f_);
     }
     else
@@ -1673,9 +1682,9 @@ function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,
 {
     if (__f.__f_ == 0)
         __f_ = 0;
-    else if (__f.__f_ == (const __base*)&__f.__buf_)
+    else if ((void *)__f.__f_ == &__f.__buf_)
     {
-        __f_ = (__base*)&__buf_;
+        __f_ = __as_base(&__buf_);
         __f.__f_->__clone(__f_);
     }
     else
@@ -1687,9 +1696,9 @@ function<_Rp(_ArgTypes...)>::function(function&& __f) _NOEXCEPT
 {
     if (__f.__f_ == 0)
         __f_ = 0;
-    else if (__f.__f_ == (__base*)&__f.__buf_)
+    else if ((void *)__f.__f_ == &__f.__buf_)
     {
-        __f_ = (__base*)&__buf_;
+        __f_ = __as_base(&__buf_);
         __f.__f_->__clone(__f_);
     }
     else
@@ -1706,9 +1715,9 @@ function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,
 {
     if (__f.__f_ == 0)
         __f_ = 0;
-    else if (__f.__f_ == (__base*)&__f.__buf_)
+    else if ((void *)__f.__f_ == &__f.__buf_)
     {
-        __f_ = (__base*)&__buf_;
+        __f_ = __as_base(&__buf_);
         __f.__f_->__clone(__f_);
     }
     else
@@ -1733,8 +1742,7 @@ function<_Rp(_ArgTypes...)>::function(_Fp __f,
         typedef __function::__func<_Fp, allocator<_Fp>, _Rp(_ArgTypes...)> _FF;
         if (sizeof(_FF) <= sizeof(__buf_) && is_nothrow_copy_constructible<_Fp>::value)
         {
-            __f_ = (__base*)&__buf_;
-            ::new (__f_) _FF(_VSTD::move(__f));
+            __f_ = ::new((void*)&__buf_) _FF(_VSTD::move(__f));
         }
         else
         {
@@ -1763,8 +1771,7 @@ function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc& __a0, _Fp _
         if (sizeof(_FF) <= sizeof(__buf_) && 
             is_nothrow_copy_constructible<_Fp>::value && is_nothrow_copy_constructible<_Ap>::value)
         {
-            __f_ = (__base*)&__buf_;
-            ::new (__f_) _FF(_VSTD::move(__f), _Alloc(__a));
+            __f_ = ::new((void*)&__buf_) _FF(_VSTD::move(__f), _Alloc(__a));
         }
         else
         {
@@ -1788,16 +1795,16 @@ template<class _Rp, class ..._ArgTypes>
 function<_Rp(_ArgTypes...)>&
 function<_Rp(_ArgTypes...)>::operator=(function&& __f) _NOEXCEPT
 {
-    if (__f_ == (__base*)&__buf_)
+    if ((void *)__f_ == &__buf_)
         __f_->destroy();
     else if (__f_)
         __f_->destroy_deallocate();
     __f_ = 0;
     if (__f.__f_ == 0)
         __f_ = 0;
-    else if (__f.__f_ == (__base*)&__f.__buf_)
+    else if ((void *)__f.__f_ == &__f.__buf_)
     {
-        __f_ = (__base*)&__buf_;
+        __f_ = __as_base(&__buf_);
         __f.__f_->__clone(__f_);
     }
     else
@@ -1812,7 +1819,7 @@ template<class _Rp, class ..._ArgTypes>
 function<_Rp(_ArgTypes...)>&
 function<_Rp(_ArgTypes...)>::operator=(nullptr_t) _NOEXCEPT
 {
-    if (__f_ == (__base*)&__buf_)
+    if ((void *)__f_ == &__buf_)
         __f_->destroy();
     else if (__f_)
         __f_->destroy_deallocate();
@@ -1837,7 +1844,7 @@ function<_Rp(_ArgTypes...)>::operator=(_Fp&& __f)
 template<class _Rp, class ..._ArgTypes>
 function<_Rp(_ArgTypes...)>::~function()
 {
-    if (__f_ == (__base*)&__buf_)
+    if ((void *)__f_ == &__buf_)
         __f_->destroy();
     else if (__f_)
         __f_->destroy_deallocate();
@@ -1847,34 +1854,34 @@ template<class _Rp, class ..._ArgTypes>
 void
 function<_Rp(_ArgTypes...)>::swap(function& __f) _NOEXCEPT
 {
-    if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_)
+    if ((void *)__f_ == &__buf_ && (void *)__f.__f_ == &__f.__buf_)
     {
         typename aligned_storage<sizeof(__buf_)>::type __tempbuf;
-        __base* __t = (__base*)&__tempbuf;
+        __base* __t = __as_base(&__tempbuf);
         __f_->__clone(__t);
         __f_->destroy();
         __f_ = 0;
-        __f.__f_->__clone((__base*)&__buf_);
+        __f.__f_->__clone(__as_base(&__buf_));
         __f.__f_->destroy();
         __f.__f_ = 0;
-        __f_ = (__base*)&__buf_;
-        __t->__clone((__base*)&__f.__buf_);
+        __f_ = __as_base(&__buf_);
+        __t->__clone(__as_base(&__f.__buf_));
         __t->destroy();
-        __f.__f_ = (__base*)&__f.__buf_;
+        __f.__f_ = __as_base(&__f.__buf_);
     }
-    else if (__f_ == (__base*)&__buf_)
+    else if ((void *)__f_ == &__buf_)
     {
-        __f_->__clone((__base*)&__f.__buf_);
+        __f_->__clone(__as_base(&__f.__buf_));
         __f_->destroy();
         __f_ = __f.__f_;
-        __f.__f_ = (__base*)&__f.__buf_;
+        __f.__f_ = __as_base(&__f.__buf_);
     }
-    else if (__f.__f_ == (__base*)&__f.__buf_)
+    else if ((void *)__f.__f_ == &__f.__buf_)
     {
-        __f.__f_->__clone((__base*)&__buf_);
+        __f.__f_->__clone(__as_base(&__buf_));
         __f.__f_->destroy();
         __f.__f_ = __f_;
-        __f_ = (__base*)&__buf_;
+        __f_ = __as_base(&__buf_);
     }
     else
         _VSTD::swap(__f_, __f.__f_);
@@ -1973,16 +1980,29 @@ namespace placeholders
 
 template <int _Np> struct __ph {};
 
-_LIBCPP_FUNC_VIS extern __ph<1>   _1;
-_LIBCPP_FUNC_VIS extern __ph<2>   _2;
-_LIBCPP_FUNC_VIS extern __ph<3>   _3;
-_LIBCPP_FUNC_VIS extern __ph<4>   _4;
-_LIBCPP_FUNC_VIS extern __ph<5>   _5;
-_LIBCPP_FUNC_VIS extern __ph<6>   _6;
-_LIBCPP_FUNC_VIS extern __ph<7>   _7;
-_LIBCPP_FUNC_VIS extern __ph<8>   _8;
-_LIBCPP_FUNC_VIS extern __ph<9>   _9;
-_LIBCPP_FUNC_VIS extern __ph<10> _10;
+#if defined(_LIBCPP_CXX03_LANG) || defined(_LIBCPP_BUILDING_BIND)
+_LIBCPP_FUNC_VIS extern const __ph<1>   _1;
+_LIBCPP_FUNC_VIS extern const __ph<2>   _2;
+_LIBCPP_FUNC_VIS extern const __ph<3>   _3;
+_LIBCPP_FUNC_VIS extern const __ph<4>   _4;
+_LIBCPP_FUNC_VIS extern const __ph<5>   _5;
+_LIBCPP_FUNC_VIS extern const __ph<6>   _6;
+_LIBCPP_FUNC_VIS extern const __ph<7>   _7;
+_LIBCPP_FUNC_VIS extern const __ph<8>   _8;
+_LIBCPP_FUNC_VIS extern const __ph<9>   _9;
+_LIBCPP_FUNC_VIS extern const __ph<10> _10;
+#else
+constexpr __ph<1>   _1{};
+constexpr __ph<2>   _2{};
+constexpr __ph<3>   _3{};
+constexpr __ph<4>   _4{};
+constexpr __ph<5>   _5{};
+constexpr __ph<6>   _6{};
+constexpr __ph<7>   _7{};
+constexpr __ph<8>   _8{};
+constexpr __ph<9>   _9{};
+constexpr __ph<10> _10{};
+#endif // defined(_LIBCPP_CXX03_LANG) || defined(_LIBCPP_BUILDING_BIND)
 
 }  // placeholders
 
@@ -2468,6 +2488,22 @@ struct _LIBCPP_TYPE_VIS_ONLY hash<unsigned long long>
 {
 };
 
+#ifndef _LIBCPP_HAS_NO_INT128
+
+template <>
+struct _LIBCPP_TYPE_VIS_ONLY hash<__int128_t>
+    : public __scalar_hash<__int128_t>
+{
+};
+
+template <>
+struct _LIBCPP_TYPE_VIS_ONLY hash<__uint128_t>
+    : public __scalar_hash<__uint128_t>
+{
+};
+
+#endif
+
 template <>
 struct _LIBCPP_TYPE_VIS_ONLY hash<float>
     : public __scalar_hash<float>
@@ -2564,11 +2600,69 @@ struct _LIBCPP_TYPE_VIS_ONLY hash
 
 
 #if _LIBCPP_STD_VER > 14
+
 template <class _Fn, class ..._Args>
 result_of_t<_Fn&&(_Args&&...)>
-invoke(_Fn&& __f, _Args&&... __args) {
-    return __invoke(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)...);
+invoke(_Fn&& __f, _Args&&... __args)
+    noexcept(noexcept(_VSTD::__invoke(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)...)))
+{
+    return _VSTD::__invoke(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)...);
+}
+
+template <class _DecayFunc>
+class _LIBCPP_TYPE_VIS_ONLY __not_fn_imp {
+  _DecayFunc __fd;
+
+public:
+    __not_fn_imp() = delete;
+
+    template <class ..._Args>
+    _LIBCPP_INLINE_VISIBILITY
+    auto operator()(_Args&& ...__args) &
+            noexcept(noexcept(!_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...)))
+        -> decltype(!_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...))
+        { return !_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...); }
+
+    template <class ..._Args>
+    _LIBCPP_INLINE_VISIBILITY
+    auto operator()(_Args&& ...__args) &&
+            noexcept(noexcept(!_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...)))
+        -> decltype(!_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...))
+        { return !_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...); }
+
+    template <class ..._Args>
+    _LIBCPP_INLINE_VISIBILITY
+    auto operator()(_Args&& ...__args) const&
+            noexcept(noexcept(!_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...)))
+        -> decltype(!_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...))
+        { return !_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...); }
+
+
+    template <class ..._Args>
+    _LIBCPP_INLINE_VISIBILITY
+    auto operator()(_Args&& ...__args) const&&
+            noexcept(noexcept(!_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...)))
+        -> decltype(!_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...))
+        { return !_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...); }
+
+private:
+    template <class _RawFunc,
+              class = enable_if_t<!is_same<decay_t<_RawFunc>, __not_fn_imp>::value>>
+    _LIBCPP_INLINE_VISIBILITY
+    explicit __not_fn_imp(_RawFunc&& __rf)
+        : __fd(_VSTD::forward<_RawFunc>(__rf)) {}
+
+    template <class _RawFunc>
+    friend inline _LIBCPP_INLINE_VISIBILITY
+    __not_fn_imp<decay_t<_RawFunc>> not_fn(_RawFunc&&);
+};
+
+template <class _RawFunc>
+inline _LIBCPP_INLINE_VISIBILITY
+__not_fn_imp<decay_t<_RawFunc>> not_fn(_RawFunc&& __fn) {
+    return __not_fn_imp<decay_t<_RawFunc>>(_VSTD::forward<_RawFunc>(__fn));
 }
+
 #endif
 
 // struct hash<T*> in <memory>
diff --git a/include/future b/include/future
index ce15eafbf7e4..936060e173b8 100644
--- a/include/future
+++ b/include/future
@@ -322,7 +322,7 @@ template <class R, class... ArgTypes>
 class packaged_task<R(ArgTypes...)>
 {
 public:
-    typedef R result_type;
+    typedef R result_type; // extension
 
     // construction and destruction
     packaged_task() noexcept;
@@ -1482,6 +1482,7 @@ template <class _Rp>
 void
 promise<_Rp>::set_exception(exception_ptr __p)
 {
+    _LIBCPP_ASSERT( __p != nullptr, "promise::set_exception: received nullptr" );
     if (__state_ == nullptr)
         __throw_future_error(future_errc::no_state);
     __state_->set_exception(__p);
@@ -1513,6 +1514,7 @@ template <class _Rp>
 void
 promise<_Rp>::set_exception_at_thread_exit(exception_ptr __p)
 {
+    _LIBCPP_ASSERT( __p != nullptr, "promise::set_exception_at_thread_exit: received nullptr" );
     if (__state_ == nullptr)
         __throw_future_error(future_errc::no_state);
     __state_->set_exception_at_thread_exit(__p);
@@ -1629,6 +1631,7 @@ template <class _Rp>
 void
 promise<_Rp&>::set_exception(exception_ptr __p)
 {
+    _LIBCPP_ASSERT( __p != nullptr, "promise::set_exception: received nullptr" );
     if (__state_ == nullptr)
         __throw_future_error(future_errc::no_state);
     __state_->set_exception(__p);
@@ -1647,6 +1650,7 @@ template <class _Rp>
 void
 promise<_Rp&>::set_exception_at_thread_exit(exception_ptr __p)
 {
+    _LIBCPP_ASSERT( __p != nullptr, "promise::set_exception_at_thread_exit: received nullptr" );
     if (__state_ == nullptr)
         __throw_future_error(future_errc::no_state);
     __state_->set_exception_at_thread_exit(__p);
@@ -1994,7 +1998,7 @@ template<class _Rp, class ..._ArgTypes>
 class _LIBCPP_TYPE_VIS_ONLY packaged_task<_Rp(_ArgTypes...)>
 {
 public:
-    typedef _Rp result_type;
+    typedef _Rp result_type; // extension
 
 private:
     __packaged_task_function<result_type(_ArgTypes...)> __f_;
@@ -2123,7 +2127,7 @@ template<class ..._ArgTypes>
 class _LIBCPP_TYPE_VIS_ONLY packaged_task<void(_ArgTypes...)>
 {
 public:
-    typedef void result_type;
+    typedef void result_type; // extension
 
 private:
     __packaged_task_function<result_type(_ArgTypes...)> __f_;
diff --git a/include/iomanip b/include/iomanip
index a5042c7df810..9efcbe03d1ae 100644
--- a/include/iomanip
+++ b/include/iomanip
@@ -512,8 +512,6 @@ put_time(const tm* __tm, const _CharT* __fmt)
     return __iom_t10<_CharT>(__tm, __fmt);
 }
 
-#if _LIBCPP_STD_VER > 11
-
 template <class _CharT, class _Traits, class _ForwardIterator>
 std::basic_ostream<_CharT, _Traits> &
 __quoted_output ( basic_ostream<_CharT, _Traits> &__os, 
@@ -569,7 +567,7 @@ __quoted_input ( basic_istream<_CharT, _Traits> &__is, _String & __string, _Char
 }
 
 
-template <class _CharT, class _Iter, class _Traits=char_traits<_CharT>>
+template <class _CharT, class _Iter, class _Traits=char_traits<_CharT> >
 struct __quoted_output_proxy
 {
     _Iter  __first;
@@ -631,22 +629,43 @@ quoted ( const _CharT *__s, _CharT __delim = _CharT('"'), _CharT __escape =_Char
     return __quoted_output_proxy<_CharT, const _CharT *> ( __s, __end, __delim, __escape );
 }
 
+
 template <class _CharT, class _Traits, class _Allocator>
 _LIBCPP_INLINE_VISIBILITY
 __quoted_output_proxy<_CharT, typename basic_string <_CharT, _Traits, _Allocator>::const_iterator>
-quoted ( const basic_string <_CharT, _Traits, _Allocator> &__s, _CharT __delim = _CharT('"'), _CharT __escape=_CharT('\\'))
+__quoted ( const basic_string <_CharT, _Traits, _Allocator> &__s, _CharT __delim = _CharT('"'), _CharT __escape=_CharT('\\'))
 {
-    return __quoted_output_proxy<_CharT, 
-            typename basic_string <_CharT, _Traits, _Allocator>::const_iterator> 
+    return __quoted_output_proxy<_CharT,
+            typename basic_string <_CharT, _Traits, _Allocator>::const_iterator>
                     ( __s.cbegin(), __s.cend (), __delim, __escape );
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_INLINE_VISIBILITY
 __quoted_proxy<_CharT, _Traits, _Allocator>
-quoted ( basic_string <_CharT, _Traits, _Allocator> &__s, _CharT __delim = _CharT('"'), _CharT __escape=_CharT('\\'))
+__quoted ( basic_string <_CharT, _Traits, _Allocator> &__s, _CharT __delim = _CharT('"'), _CharT __escape=_CharT('\\'))
 {
     return __quoted_proxy<_CharT, _Traits, _Allocator>( __s, __delim, __escape );
 }
+
+
+#if _LIBCPP_STD_VER > 11
+
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_INLINE_VISIBILITY
+__quoted_output_proxy<_CharT, typename basic_string <_CharT, _Traits, _Allocator>::const_iterator>
+quoted ( const basic_string <_CharT, _Traits, _Allocator> &__s, _CharT __delim = _CharT('"'), _CharT __escape=_CharT('\\'))
+{
+    return __quoted(__s, __delim, __escape);
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_INLINE_VISIBILITY
+__quoted_proxy<_CharT, _Traits, _Allocator>
+quoted ( basic_string <_CharT, _Traits, _Allocator> &__s, _CharT __delim = _CharT('"'), _CharT __escape=_CharT('\\'))
+{
+    return __quoted(__s, __delim, __escape);
+}
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/include/ios b/include/ios
index 1deb5f613c8a..cbea478a74a8 100644
--- a/include/ios
+++ b/include/ios
@@ -231,7 +231,7 @@ typedef ptrdiff_t streamsize;
 class _LIBCPP_TYPE_VIS ios_base
 {
 public:
-    class _LIBCPP_TYPE_VIS failure;
+    class _LIBCPP_EXCEPTION_ABI failure;
 
     typedef unsigned int fmtflags;
     static const fmtflags boolalpha   = 0x0001;
diff --git a/include/iosfwd b/include/iosfwd
index eccfd349a4a5..e4149ef22378 100644
--- a/include/iosfwd
+++ b/include/iosfwd
@@ -194,6 +194,11 @@ template <class _CharT,             // for <stdexcept>
 typedef basic_string<char, char_traits<char>, allocator<char> > string;
 typedef basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> > wstring;
 
+
+// Include other forward declarations here
+template <class _Tp, class _Alloc = allocator<_Tp> >
+class _LIBCPP_TYPE_VIS_ONLY vector;
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_IOSFWD
diff --git a/include/istream b/include/istream
index 0bcc7eeaf639..ee694003a3d8 100644
--- a/include/istream
+++ b/include/istream
@@ -1251,18 +1251,35 @@ streamsize
 basic_istream<_CharT, _Traits>::readsome(char_type* __s, streamsize __n)
 {
     __gc_ = 0;
-    streamsize __c = this->rdbuf()->in_avail();
-    switch (__c)
-    {
-    case -1:
-        this->setstate(ios_base::eofbit);
-        break;
-    case 0:
-        break;
-    default:
-        read(__s, _VSTD::min(__c, __n));
-        break;
+#ifndef _LIBCPP_NO_EXCEPTIONS
+    try
+    {
+#endif  // _LIBCPP_NO_EXCEPTIONS
+        sentry __sen(*this, true);
+        if (__sen)
+        {
+            streamsize __c = this->rdbuf()->in_avail();
+            switch (__c)
+            {
+            case -1:
+                this->setstate(ios_base::eofbit);
+                break;
+            case 0:
+                break;
+            default:
+                read(__s, _VSTD::min(__c, __n));
+                break;
+            }
+        }
+        else
+            this->setstate(ios_base::failbit);
+#ifndef _LIBCPP_NO_EXCEPTIONS
     }
+    catch (...)
+    {
+        this->__set_badbit_and_consider_rethrow();
+    }
+#endif  // _LIBCPP_NO_EXCEPTIONS
     return __gc_;
 }
 
diff --git a/include/iterator b/include/iterator
index 8d9b31101bdf..abd142e85aa3 100644
--- a/include/iterator
+++ b/include/iterator
@@ -131,8 +131,9 @@ bool
 operator<=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);
 
 template <class Iterator1, class Iterator2>
-typename reverse_iterator<Iterator1>::difference_type
-operator-(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);
+auto
+operator-(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y)
+-> decltype(__y.base() - __x.base());
 
 template <class Iterator>
 reverse_iterator<Iterator>
@@ -149,7 +150,7 @@ public:
     typedef Container                   container_type;
     typedef void                        value_type;
     typedef void                        difference_type;
-    typedef back_insert_iterator<Cont>& reference;
+    typedef void                        reference;
     typedef void                        pointer;
 
     explicit back_insert_iterator(Container& x);
@@ -170,7 +171,7 @@ public:
     typedef Container                    container_type;
     typedef void                         value_type;
     typedef void                         difference_type;
-    typedef front_insert_iterator<Cont>& reference;
+    typedef void                         reference;
     typedef void                         pointer;
 
     explicit front_insert_iterator(Container& x);
@@ -192,7 +193,7 @@ public:
     typedef Container              container_type;
     typedef void                   value_type;
     typedef void                   difference_type;
-    typedef insert_iterator<Cont>& reference;
+    typedef void                   reference;
     typedef void                   pointer;
 
     insert_iterator(Container& x, typename Container::iterator i);
@@ -205,6 +206,73 @@ public:
 template <class Container, class Iterator>
 insert_iterator<Container> inserter(Container& x, Iterator i);
 
+template <class Iterator>
+class move_iterator {
+public:
+    typedef Iterator                                              iterator_type;
+    typedef typename iterator_traits<Iterator>::difference_type   difference_type;
+    typedef Iterator                                              pointer;
+    typedef typename iterator_traits<Iterator>::value_type        value_type;
+    typedef typename iterator_traits<Iterator>::iterator_category iterator_category;
+    typedef value_type&&                                          reference;
+ 
+    move_iterator();
+    explicit move_iterator(Iterator i);
+    template <class U> move_iterator(const move_iterator<U>& u);
+    template <class U> move_iterator& operator=(const move_iterator<U>& u);
+    iterator_type base() const;
+    reference operator*() const;
+    pointer operator->() const;
+    move_iterator& operator++();
+    move_iterator operator++(int);
+    move_iterator& operator--();
+    move_iterator operator--(int);
+    move_iterator operator+(difference_type n) const; 
+    move_iterator& operator+=(difference_type n); 
+    move_iterator operator-(difference_type n) const; 
+    move_iterator& operator-=(difference_type n); 
+    unspecified operator[](difference_type n) const;
+private:
+    Iterator current; // exposition only
+};
+
+template <class Iterator1, class Iterator2>
+bool
+operator==(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
+
+template <class Iterator1, class Iterator2>
+bool
+operator!=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
+
+template <class Iterator1, class Iterator2>
+bool
+operator<(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
+
+template <class Iterator1, class Iterator2>
+bool
+operator<=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
+
+template <class Iterator1, class Iterator2>
+bool
+operator>(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
+
+template <class Iterator1, class Iterator2>
+bool
+operator>=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
+
+template <class Iterator1, class Iterator2>
+auto
+operator-(const move_iterator<Iterator1>& x,
+          const move_iterator<Iterator2>& y) -> decltype(x.base() - y.base());
+
+template <class Iterator>
+move_iterator<Iterator> operator+(typename move_iterator<Iterator>::difference_type n, 
+                                     const move_iterator<Iterator>& x);
+
+template <class Iterator>
+move_iterator<Iterator> make_move_iterator(const Iterator& i);
+
+
 template <class T, class charT = char, class traits = char_traits<charT>, class Distance = ptrdiff_t>
 class istream_iterator
     : public iterator<input_iterator_tag, T, Distance, const T*, const T&>
@@ -340,10 +408,10 @@ template <class E> constexpr const E* data(initializer_list<E> il) noexcept;
 */
 
 #include <__config>
+#include <iosfwd> // for forward declarations of vector and string.
 #include <__functional_base>
 #include <type_traits>
 #include <cstddef>
-#include <iosfwd>
 #include <initializer_list>
 #ifdef __APPLE__
 #include <Availability.h>
@@ -632,6 +700,16 @@ operator<=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>&
     return __x.base() >= __y.base();
 }
 
+#ifndef _LIBCPP_CXX03_LANG
+template <class _Iter1, class _Iter2>
+inline _LIBCPP_INLINE_VISIBILITY
+auto
+operator-(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
+-> decltype(__y.base() - __x.base())
+{
+    return __y.base() - __x.base();
+}
+#else
 template <class _Iter1, class _Iter2>
 inline _LIBCPP_INLINE_VISIBILITY
 typename reverse_iterator<_Iter1>::difference_type
@@ -639,6 +717,7 @@ operator-(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& _
 {
     return __y.base() - __x.base();
 }
+#endif
 
 template <class _Iter>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -663,7 +742,7 @@ class _LIBCPP_TYPE_VIS_ONLY back_insert_iterator
                       void,
                       void,
                       void,
-                      back_insert_iterator<_Container>&>
+                      void>
 {
 protected:
     _Container* container;
@@ -696,7 +775,7 @@ class _LIBCPP_TYPE_VIS_ONLY front_insert_iterator
                       void,
                       void,
                       void,
-                      front_insert_iterator<_Container>&>
+                      void>
 {
 protected:
     _Container* container;
@@ -729,7 +808,7 @@ class _LIBCPP_TYPE_VIS_ONLY insert_iterator
                       void,
                       void,
                       void,
-                      insert_iterator<_Container>&>
+                      void>
 {
 protected:
     _Container* container;
@@ -772,14 +851,14 @@ private:
     _Tp __value_;
 public:
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR istream_iterator() : __in_stream_(0), __value_() {}
-    _LIBCPP_INLINE_VISIBILITY istream_iterator(istream_type& __s) : __in_stream_(&__s)
+    _LIBCPP_INLINE_VISIBILITY istream_iterator(istream_type& __s) : __in_stream_(_VSTD::addressof(__s))
         {
             if (!(*__in_stream_ >> __value_))
                 __in_stream_ = 0;
         }
 
     _LIBCPP_INLINE_VISIBILITY const _Tp& operator*() const {return __value_;}
-    _LIBCPP_INLINE_VISIBILITY const _Tp* operator->() const {return &(operator*());}
+    _LIBCPP_INLINE_VISIBILITY const _Tp* operator->() const {return _VSTD::addressof((operator*()));}
     _LIBCPP_INLINE_VISIBILITY istream_iterator& operator++()
         {
             if (!(*__in_stream_ >> __value_))
@@ -811,9 +890,9 @@ private:
     const char_type* __delim_;
 public:
     _LIBCPP_INLINE_VISIBILITY ostream_iterator(ostream_type& __s)
-        : __out_stream_(&__s), __delim_(0) {}
+        : __out_stream_(_VSTD::addressof(__s)), __delim_(0) {}
     _LIBCPP_INLINE_VISIBILITY ostream_iterator(ostream_type& __s, const _CharT* __delimiter)
-        : __out_stream_(&__s), __delim_(__delimiter) {}
+        : __out_stream_(_VSTD::addressof(__s)), __delim_(__delimiter) {}
     _LIBCPP_INLINE_VISIBILITY ostream_iterator& operator=(const _Tp& __value_)
         {
             *__out_stream_ << __value_;
@@ -949,9 +1028,14 @@ public:
     typedef typename iterator_traits<iterator_type>::iterator_category iterator_category;
     typedef typename iterator_traits<iterator_type>::value_type value_type;
     typedef typename iterator_traits<iterator_type>::difference_type difference_type;
-    typedef typename iterator_traits<iterator_type>::pointer pointer;
+    typedef iterator_type pointer;
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    typedef value_type&& reference;
+    typedef typename iterator_traits<iterator_type>::reference __reference;
+    typedef typename conditional<
+            is_reference<__reference>::value,
+            typename remove_reference<__reference>::type&&,
+            __reference
+        >::type reference;
 #else
     typedef typename iterator_traits<iterator_type>::reference reference;
 #endif
@@ -964,10 +1048,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY reference operator*() const {
       return static_cast<reference>(*__i);
     }
-    _LIBCPP_INLINE_VISIBILITY pointer  operator->() const {
-      typename iterator_traits<iterator_type>::reference __ref = *__i;
-      return &__ref;
-    }
+    _LIBCPP_INLINE_VISIBILITY pointer  operator->() const { return __i;}
     _LIBCPP_INLINE_VISIBILITY move_iterator& operator++() {++__i; return *this;}
     _LIBCPP_INLINE_VISIBILITY move_iterator  operator++(int)
         {move_iterator __tmp(*this); ++__i; return __tmp;}
@@ -1036,6 +1117,16 @@ operator<=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
     return __x.base() <= __y.base();
 }
 
+#ifndef _LIBCPP_CXX03_LANG
+template <class _Iter1, class _Iter2>
+inline _LIBCPP_INLINE_VISIBILITY
+auto
+operator-(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
+-> decltype(__x.base() - __y.base())
+{
+    return __x.base() - __y.base();
+}
+#else
 template <class _Iter1, class _Iter2>
 inline _LIBCPP_INLINE_VISIBILITY
 typename move_iterator<_Iter1>::difference_type
@@ -1043,6 +1134,7 @@ operator-(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
 {
     return __x.base() - __y.base();
 }
+#endif
 
 template <class _Iter>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1094,10 +1186,18 @@ _LIBCPP_INLINE_VISIBILITY
 bool
 operator<=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
 
+#ifndef _LIBCPP_CXX03_LANG
+template <class _Iter1, class _Iter2>
+_LIBCPP_INLINE_VISIBILITY
+auto
+operator-(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
+-> decltype(__x.base() - __y.base());
+#else
 template <class _Iter1, class _Iter2>
 _LIBCPP_INLINE_VISIBILITY
 typename __wrap_iter<_Iter1>::difference_type
 operator-(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
+#endif
 
 template <class _Iter>
 _LIBCPP_INLINE_VISIBILITY
@@ -1185,7 +1285,7 @@ public:
         _LIBCPP_ASSERT(__get_const_db()->__dereferenceable(this),
                        "Attempted to dereference a non-dereferenceable iterator");
 #endif
-        return (pointer)&reinterpret_cast<const volatile char&>(*__i);
+        return (pointer)_VSTD::addressof(*__i);
     }
     _LIBCPP_INLINE_VISIBILITY __wrap_iter& operator++() _NOEXCEPT
     {
@@ -1279,10 +1379,18 @@ private:
     bool
     operator<=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
 
+#ifndef _LIBCPP_CXX03_LANG
+    template <class _Iter1, class _Iter2>
+    friend
+    auto
+    operator-(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
+    -> decltype(__x.base() - __y.base());
+#else
     template <class _Iter1, class _Iter2>
     friend
     typename __wrap_iter<_Iter1>::difference_type
     operator-(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
+#endif
 
     template <class _Iter1>
     friend
@@ -1388,6 +1496,20 @@ operator<=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEX
     return !(__y < __x);
 }
 
+#ifndef _LIBCPP_CXX03_LANG
+template <class _Iter1, class _Iter2>
+inline _LIBCPP_INLINE_VISIBILITY
+auto
+operator-(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
+-> decltype(__x.base() - __y.base())
+{
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    _LIBCPP_ASSERT(__get_const_db()->__less_than_comparable(&__x, &__y),
+                   "Attempted to subtract incompatible iterators");
+#endif
+    return __x.base() - __y.base();
+}
+#else
 template <class _Iter1, class _Iter2>
 inline _LIBCPP_INLINE_VISIBILITY
 typename __wrap_iter<_Iter1>::difference_type
@@ -1399,6 +1521,7 @@ operator-(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXC
 #endif
     return __x.base() - __y.base();
 }
+#endif
 
 template <class _Iter>
 inline _LIBCPP_INLINE_VISIBILITY
diff --git a/include/list b/include/list
index 44b20e2fa28c..cff0a853eff9 100644
--- a/include/list
+++ b/include/list
@@ -570,10 +570,13 @@ protected:
     const __node_allocator& __node_alloc() const _NOEXCEPT
         {return __size_alloc_.second();}
 
+    _LIBCPP_INLINE_VISIBILITY
     static void __unlink_nodes(__link_pointer __f, __link_pointer __l) _NOEXCEPT;
 
+    _LIBCPP_INLINE_VISIBILITY
     __list_imp()
         _NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value);
+    _LIBCPP_INLINE_VISIBILITY
     __list_imp(const allocator_type& __a);
     ~__list_imp();
     void clear() _NOEXCEPT;
@@ -666,7 +669,7 @@ private:
 
 // Unlink nodes [__f, __l]
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 __list_imp<_Tp, _Alloc>::__unlink_nodes(__link_pointer __f, __link_pointer __l)
     _NOEXCEPT
@@ -676,7 +679,7 @@ __list_imp<_Tp, _Alloc>::__unlink_nodes(__link_pointer __f, __link_pointer __l)
 }
 
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 __list_imp<_Tp, _Alloc>::__list_imp()
         _NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value)
     : __size_alloc_(0)
@@ -684,7 +687,7 @@ __list_imp<_Tp, _Alloc>::__list_imp()
 }
 
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 __list_imp<_Tp, _Alloc>::__list_imp(const allocator_type& __a)
     : __size_alloc_(0, __node_allocator(__a))
 {
@@ -858,15 +861,19 @@ public:
 
     list(const list& __c);
     list(const list& __c, const allocator_type& __a);
+    _LIBCPP_INLINE_VISIBILITY
     list& operator=(const list& __c);
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     list(initializer_list<value_type> __il);
     list(initializer_list<value_type> __il, const allocator_type& __a);
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     list(list&& __c)
         _NOEXCEPT_(is_nothrow_move_constructible<__node_allocator>::value);
+    _LIBCPP_INLINE_VISIBILITY
     list(list&& __c, const allocator_type& __a);
+    _LIBCPP_INLINE_VISIBILITY
     list& operator=(list&& __c)
         _NOEXCEPT_(
             __node_alloc_traits::propagate_on_container_move_assignment::value &&
@@ -888,6 +895,7 @@ public:
         {assign(__il.begin(), __il.end());}
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
+    _LIBCPP_INLINE_VISIBILITY
     allocator_type get_allocator() const _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY
@@ -1024,9 +1032,11 @@ public:
 
     void remove(const value_type& __x);
     template <class _Pred> void remove_if(_Pred __pred);
+    _LIBCPP_INLINE_VISIBILITY
     void unique();
     template <class _BinaryPred>
         void unique(_BinaryPred __binary_pred);
+    _LIBCPP_INLINE_VISIBILITY
     void merge(list& __c);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
@@ -1039,8 +1049,10 @@ public:
     _LIBCPP_INLINE_VISIBILITY
         void merge(list&& __c, _Comp __comp) {merge(__c, __comp);}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     void sort();
     template <class _Comp>
+        _LIBCPP_INLINE_VISIBILITY
         void sort(_Comp __comp);
 
     void reverse() _NOEXCEPT;
@@ -1057,8 +1069,11 @@ public:
 #endif  // _LIBCPP_DEBUG_LEVEL >= 2
 
 private:
+    _LIBCPP_INLINE_VISIBILITY
     static void __link_nodes  (__link_pointer __p, __link_pointer __f, __link_pointer __l);
+    _LIBCPP_INLINE_VISIBILITY
     void __link_nodes_at_front(__link_pointer __f, __link_pointer __l);
+    _LIBCPP_INLINE_VISIBILITY
     void __link_nodes_at_back (__link_pointer __f, __link_pointer __l);
     iterator __iterator(size_type __n);
     template <class _Comp>
@@ -1071,7 +1086,7 @@ private:
 
 // Link in nodes [__f, __l] just prior to __p
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 list<_Tp, _Alloc>::__link_nodes(__link_pointer __p, __link_pointer __f, __link_pointer __l)
 {
@@ -1083,7 +1098,7 @@ list<_Tp, _Alloc>::__link_nodes(__link_pointer __p, __link_pointer __f, __link_p
 
 // Link in nodes [__f, __l] at the front of the list
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 list<_Tp, _Alloc>::__link_nodes_at_front(__link_pointer __f, __link_pointer __l)
 {
@@ -1095,7 +1110,7 @@ list<_Tp, _Alloc>::__link_nodes_at_front(__link_pointer __f, __link_pointer __l)
 
 // Link in nodes [__f, __l] at the front of the list
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 list<_Tp, _Alloc>::__link_nodes_at_back(__link_pointer __f, __link_pointer __l)
 {
@@ -1107,7 +1122,7 @@ list<_Tp, _Alloc>::__link_nodes_at_back(__link_pointer __f, __link_pointer __l)
 
 
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename list<_Tp, _Alloc>::iterator
 list<_Tp, _Alloc>::__iterator(size_type __n)
 {
@@ -1243,7 +1258,7 @@ list<_Tp, _Alloc>::list(initializer_list<value_type> __il)
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 list<_Tp, _Alloc>&
 list<_Tp, _Alloc>::operator=(const list& __c)
 {
@@ -1258,7 +1273,7 @@ list<_Tp, _Alloc>::operator=(const list& __c)
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 list<_Tp, _Alloc>::list(list&& __c)
     _NOEXCEPT_(is_nothrow_move_constructible<__node_allocator>::value)
     : base(allocator_type(_VSTD::move(__c.__node_alloc())))
@@ -1270,7 +1285,7 @@ list<_Tp, _Alloc>::list(list&& __c)
 }
 
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 list<_Tp, _Alloc>::list(list&& __c, const allocator_type& __a)
     : base(__a)
 {
@@ -1287,7 +1302,7 @@ list<_Tp, _Alloc>::list(list&& __c, const allocator_type& __a)
 }
 
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 list<_Tp, _Alloc>&
 list<_Tp, _Alloc>::operator=(list&& __c)
         _NOEXCEPT_(
@@ -1355,7 +1370,7 @@ list<_Tp, _Alloc>::assign(size_type __n, const value_type& __x)
 }
 
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 _Alloc
 list<_Tp, _Alloc>::get_allocator() const _NOEXCEPT
 {
@@ -2108,7 +2123,7 @@ list<_Tp, _Alloc>::remove_if(_Pred __pred)
 }
 
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 list<_Tp, _Alloc>::unique()
 {
@@ -2131,7 +2146,7 @@ list<_Tp, _Alloc>::unique(_BinaryPred __binary_pred)
 }
 
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 list<_Tp, _Alloc>::merge(list& __c)
 {
@@ -2193,7 +2208,7 @@ list<_Tp, _Alloc>::merge(list& __c, _Comp __comp)
 }
 
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 list<_Tp, _Alloc>::sort()
 {
@@ -2202,7 +2217,7 @@ list<_Tp, _Alloc>::sort()
 
 template <class _Tp, class _Alloc>
 template <class _Comp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 list<_Tp, _Alloc>::sort(_Comp __comp)
 {
diff --git a/include/locale b/include/locale
index 84cb5a5ef6cd..3d804e86f4d1 100644
--- a/include/locale
+++ b/include/locale
@@ -180,6 +180,7 @@ template <class charT> class messages_byname;
 
 #include <__config>
 #include <__locale>
+#include <__debug>
 #include <algorithm>
 #include <memory>
 #include <ios>
@@ -213,6 +214,12 @@ template <class charT> class messages_byname;
 #pragma GCC system_header
 #endif
 
+#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
+#include <__bsd_locale_defaults.h>
+#else
+#include <__bsd_locale_fallbacks.h>
+#endif
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if defined(__APPLE__) || defined(__FreeBSD__)
@@ -228,189 +235,6 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 typedef _VSTD::remove_pointer<locale_t>::type __locale_struct;
 typedef _VSTD::unique_ptr<__locale_struct, decltype(&freelocale)> __locale_unique_ptr;
-#ifndef _LIBCPP_LOCALE__L_EXTENSIONS
-typedef _VSTD::unique_ptr<__locale_struct, decltype(&uselocale)> __locale_raii;
-#endif
-
-// OSX has nice foo_l() functions that let you turn off use of the global
-// locale.  Linux, not so much.  The following functions avoid the locale when
-// that's possible and otherwise do the wrong thing.  FIXME.
-#if defined(__linux__) || defined(__EMSCRIPTEN__) || defined(_AIX) || \
-    defined(_NEWLIB_VERSION) || defined(__GLIBC__)
-
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-decltype(MB_CUR_MAX_L(_VSTD::declval<locale_t>()))
-inline _LIBCPP_INLINE_VISIBILITY
-__mb_cur_max_l(locale_t __l)
-{
-  return MB_CUR_MAX_L(__l);
-}
-#else  // _LIBCPP_LOCALE__L_EXTENSIONS
-inline _LIBCPP_ALWAYS_INLINE
-decltype(MB_CUR_MAX) __mb_cur_max_l(locale_t __l)
-{
-  __locale_raii __current(uselocale(__l), uselocale);
-  return MB_CUR_MAX;
-}
-#endif // _LIBCPP_LOCALE__L_EXTENSIONS
-
-inline _LIBCPP_ALWAYS_INLINE
-wint_t __btowc_l(int __c, locale_t __l)
-{
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-  return btowc_l(__c, __l);
-#else
-  __locale_raii __current(uselocale(__l), uselocale);
-  return btowc(__c);
-#endif
-}
-
-inline _LIBCPP_ALWAYS_INLINE
-int __wctob_l(wint_t __c, locale_t __l)
-{
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-  return wctob_l(__c, __l);
-#else
-  __locale_raii __current(uselocale(__l), uselocale);
-  return wctob(__c);
-#endif
-}
-
-inline _LIBCPP_ALWAYS_INLINE
-size_t __wcsnrtombs_l(char *__dest, const wchar_t **__src, size_t __nwc,
-                      size_t __len, mbstate_t *__ps, locale_t __l)
-{
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-  return wcsnrtombs_l(__dest, __src, __nwc, __len, __ps, __l);
-#else
-  __locale_raii __current(uselocale(__l), uselocale);
-  return wcsnrtombs(__dest, __src, __nwc, __len, __ps);
-#endif
-}
-
-inline _LIBCPP_ALWAYS_INLINE
-size_t __wcrtomb_l(char *__s, wchar_t __wc, mbstate_t *__ps, locale_t __l)
-{
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-  return wcrtomb_l(__s, __wc, __ps, __l);
-#else
-  __locale_raii __current(uselocale(__l), uselocale);
-  return wcrtomb(__s, __wc, __ps);
-#endif
-}
-
-inline _LIBCPP_ALWAYS_INLINE
-size_t __mbsnrtowcs_l(wchar_t * __dest, const char **__src, size_t __nms,
-                      size_t __len, mbstate_t *__ps, locale_t __l)
-{
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-  return mbsnrtowcs_l(__dest, __src, __nms, __len, __ps, __l);
-#else
-  __locale_raii __current(uselocale(__l), uselocale);
-  return mbsnrtowcs(__dest, __src, __nms, __len, __ps);
-#endif
-}
-
-inline _LIBCPP_ALWAYS_INLINE
-size_t __mbrtowc_l(wchar_t *__pwc, const char *__s, size_t __n,
-                   mbstate_t *__ps, locale_t __l)
-{
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-  return mbrtowc_l(__pwc, __s, __n, __ps, __l);
-#else
-  __locale_raii __current(uselocale(__l), uselocale);
-  return mbrtowc(__pwc, __s, __n, __ps);
-#endif
-}
-
-inline _LIBCPP_ALWAYS_INLINE
-int __mbtowc_l(wchar_t *__pwc, const char *__pmb, size_t __max, locale_t __l)
-{
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-  return mbtowc_l(__pwc, __pmb, __max, __l);
-#else
-  __locale_raii __current(uselocale(__l), uselocale);
-  return mbtowc(__pwc, __pmb, __max);
-#endif
-}
-
-inline _LIBCPP_ALWAYS_INLINE
-size_t __mbrlen_l(const char *__s, size_t __n, mbstate_t *__ps, locale_t __l)
-{
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-  return mbrlen_l(__s, __n, __ps, __l);
-#else
-  __locale_raii __current(uselocale(__l), uselocale);
-  return mbrlen(__s, __n, __ps);
-#endif
-}
-
-inline _LIBCPP_ALWAYS_INLINE
-lconv *__localeconv_l(locale_t __l)
-{
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-  return localeconv_l(__l);
-#else
-  __locale_raii __current(uselocale(__l), uselocale);
-  return localeconv();
-#endif
-}
-
-inline _LIBCPP_ALWAYS_INLINE
-size_t __mbsrtowcs_l(wchar_t *__dest, const char **__src, size_t __len,
-                     mbstate_t *__ps, locale_t __l)
-{
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-  return mbsrtowcs_l(__dest, __src, __len, __ps, __l);
-#else
-  __locale_raii __current(uselocale(__l), uselocale);
-  return mbsrtowcs(__dest, __src, __len, __ps);
-#endif
-}
-
-inline
-int __snprintf_l(char *__s, size_t __n, locale_t __l, const char *__format, ...) {
-  va_list __va;
-  va_start(__va, __format);
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-  int __res = vsnprintf_l(__s, __n, __l, __format, __va);
-#else
-  __locale_raii __current(uselocale(__l), uselocale);
-  int __res = vsnprintf(__s, __n, __format, __va);
-#endif
-  va_end(__va);
-  return __res;
-}
-
-inline
-int __asprintf_l(char **__s, locale_t __l, const char *__format, ...) {
-  va_list __va;
-  va_start(__va, __format);
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-  int __res = vasprintf_l(__s, __l, __format, __va);
-#else
-  __locale_raii __current(uselocale(__l), uselocale);
-  int __res = vasprintf(__s, __format, __va);
-#endif
-  va_end(__va);
-  return __res;
-}
-
-inline
-int __sscanf_l(const char *__s, locale_t __l, const char *__format, ...) {
-  va_list __va;
-  va_start(__va, __format);
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-  int __res = vsscanf_l(__s, __l, __format, __va);
-#else
-  __locale_raii __current(uselocale(__l), uselocale);
-  int __res = vsscanf(__s, __format, __va);
-#endif
-  va_end(__va);
-  return __res;
-}
-
-#endif  // __linux__
 
 // __scan_keyword
 // Scans [__b, __e) until a match is found in the basic_strings range
@@ -933,6 +757,28 @@ __num_get_unsigned_integral(const char* __a, const char* __a_end,
 }
 
 template <class _Tp>
+_LIBCPP_INLINE_VISIBILITY
+_Tp __do_strtod(const char* __a, char** __p2);
+
+template <>
+inline _LIBCPP_INLINE_VISIBILITY
+float __do_strtod<float>(const char* __a, char** __p2) {
+    return strtof_l(__a, __p2, _LIBCPP_GET_C_LOCALE);
+}
+
+template <>
+inline _LIBCPP_INLINE_VISIBILITY
+double __do_strtod<double>(const char* __a, char** __p2) {
+    return strtod_l(__a, __p2, _LIBCPP_GET_C_LOCALE);
+}
+
+template <>
+inline _LIBCPP_INLINE_VISIBILITY
+long double __do_strtod<long double>(const char* __a, char** __p2) {
+    return strtold_l(__a, __p2, _LIBCPP_GET_C_LOCALE);
+}
+
+template <class _Tp>
 _Tp
 __num_get_float(const char* __a, const char* __a_end, ios_base::iostate& __err)
 {
@@ -941,7 +787,7 @@ __num_get_float(const char* __a, const char* __a_end, ios_base::iostate& __err)
         typename remove_reference<decltype(errno)>::type __save_errno = errno;
         errno = 0;
         char *__p2;
-        long double __ld = strtold_l(__a, &__p2, _LIBCPP_GET_C_LOCALE);
+        _Tp __ld = __do_strtod<_Tp>(__a, &__p2);
         typename remove_reference<decltype(errno)>::type __current_errno = errno;
         if (__current_errno == 0)
             errno = __save_errno;
@@ -952,7 +798,7 @@ __num_get_float(const char* __a, const char* __a_end, ios_base::iostate& __err)
         }
         else if (__current_errno == ERANGE)
             __err = ios_base::failbit;
-        return static_cast<_Tp>(__ld);
+        return __ld;
     }
     __err = ios_base::failbit;
     return 0;
@@ -1188,11 +1034,7 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
     }
     // Stage 3
     __buf.resize(__a_end - __a);
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-    if (sscanf_l(__buf.c_str(), _LIBCPP_GET_C_LOCALE, "%p", &__v) != 1)
-#else
-    if (__sscanf_l(__buf.c_str(), _LIBCPP_GET_C_LOCALE, "%p", &__v) != 1)
-#endif
+    if (__libcpp_sscanf_l(__buf.c_str(), _LIBCPP_GET_C_LOCALE, "%p", &__v) != 1)
         __err = ios_base::failbit;
     // EOF checked
     if (__b == __e)
@@ -1556,13 +1398,9 @@ num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
     this->__format_int(__fmt+1, __len, true, __iob.flags());
     const unsigned __nbuf = (numeric_limits<long>::digits / 3)
                           + ((numeric_limits<long>::digits % 3) != 0)
-                          + 1;
+                          + 2;
     char __nar[__nbuf];
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-    int __nc = snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v);
-#else
-    int __nc = __snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v);
-#endif
+    int __nc = __libcpp_snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v);
     char* __ne = __nar + __nc;
     char* __np = this->__identify_padding(__nar, __ne, __iob);
     // Stage 2 - Widen __nar while adding thousands separators
@@ -1588,11 +1426,7 @@ num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
                           + ((numeric_limits<long long>::digits % 3) != 0)
                           + 2;
     char __nar[__nbuf];
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-    int __nc = snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v);
-#else
-    int __nc = __snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v);
-#endif
+    int __nc = __libcpp_snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v);
     char* __ne = __nar + __nc;
     char* __np = this->__identify_padding(__nar, __ne, __iob);
     // Stage 2 - Widen __nar while adding thousands separators
@@ -1618,11 +1452,7 @@ num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
                           + ((numeric_limits<unsigned long>::digits % 3) != 0)
                           + 1;
     char __nar[__nbuf];
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-    int __nc = snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v);
-#else
-    int __nc = __snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v);
-#endif
+    int __nc = __libcpp_snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v);
     char* __ne = __nar + __nc;
     char* __np = this->__identify_padding(__nar, __ne, __iob);
     // Stage 2 - Widen __nar while adding thousands separators
@@ -1648,11 +1478,7 @@ num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
                           + ((numeric_limits<unsigned long long>::digits % 3) != 0)
                           + 1;
     char __nar[__nbuf];
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-    int __nc = snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v);
-#else
-    int __nc = __snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v);
-#endif
+    int __nc = __libcpp_snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v);
     char* __ne = __nar + __nc;
     char* __np = this->__identify_padding(__nar, __ne, __iob);
     // Stage 2 - Widen __nar while adding thousands separators
@@ -1679,34 +1505,17 @@ num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
     char* __nb = __nar;
     int __nc;
     if (__specify_precision)
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-        __nc = snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt,
+        __nc = __libcpp_snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt,
                                    (int)__iob.precision(), __v);
-#else
-        __nc = __snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt,
-                                   (int)__iob.precision(), __v);
-#endif
     else
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-        __nc = snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt, __v);
-#else
-        __nc = __snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt, __v);
-#endif
+        __nc = __libcpp_snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt, __v);
     unique_ptr<char, void(*)(void*)> __nbh(0, free);
     if (__nc > static_cast<int>(__nbuf-1))
     {
         if (__specify_precision)
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-            __nc = asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, (int)__iob.precision(), __v);
-#else
-            __nc = __asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, (int)__iob.precision(), __v);
-#endif
+            __nc = __libcpp_asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, (int)__iob.precision(), __v);
         else
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-            __nc = asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, __v);
-#else
-            __nc = __asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, (int)__iob.precision(), __v);
-#endif
+            __nc = __libcpp_asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, __v);
         if (__nb == 0)
             __throw_bad_alloc();
         __nbh.reset(__nb);
@@ -1747,34 +1556,17 @@ num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
     char* __nb = __nar;
     int __nc;
     if (__specify_precision)
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-        __nc = snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt,
-                                   (int)__iob.precision(), __v);
-#else
-        __nc = __snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt,
+        __nc = __libcpp_snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt,
                                    (int)__iob.precision(), __v);
-#endif
     else
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-        __nc = snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt, __v);
-#else
-        __nc = __snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt, __v);
-#endif
+        __nc = __libcpp_snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt, __v);
     unique_ptr<char, void(*)(void*)> __nbh(0, free);
     if (__nc > static_cast<int>(__nbuf-1))
     {
         if (__specify_precision)
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-            __nc = asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, (int)__iob.precision(), __v);
-#else
-            __nc = __asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, (int)__iob.precision(), __v);
-#endif
+            __nc = __libcpp_asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, (int)__iob.precision(), __v);
         else
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-            __nc = asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, __v);
-#else
-            __nc = __asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, __v);
-#endif
+            __nc = __libcpp_asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, __v);
         if (__nb == 0)
             __throw_bad_alloc();
         __nbh.reset(__nb);
@@ -1810,11 +1602,7 @@ num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
     char __fmt[6] = "%p";
     const unsigned __nbuf = 20;
     char __nar[__nbuf];
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-    int __nc = snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v);
-#else
-    int __nc = __snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v);
-#endif
+    int __nc = __libcpp_snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v);
     char* __ne = __nar + __nc;
     char* __np = this->__identify_padding(__nar, __ne, __iob);
     // Stage 2 - Widen __nar
@@ -3526,11 +3314,7 @@ money_put<_CharT, _OutputIterator>::do_put(iter_type __s, bool __intl,
     // secure memory for digit storage
     if (__n > __bs-1)
     {
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-        __n = static_cast<size_t>(asprintf_l(&__bb, _LIBCPP_GET_C_LOCALE, "%.0Lf", __units));
-#else
-        __n = __asprintf_l(&__bb, _LIBCPP_GET_C_LOCALE, "%.0Lf", __units);
-#endif
+        __n = static_cast<size_t>(__libcpp_asprintf_l(&__bb, _LIBCPP_GET_C_LOCALE, "%.0Lf", __units));
         if (__bb == 0)
             __throw_bad_alloc();
         __hn.reset(__bb);
@@ -3850,7 +3634,7 @@ wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
         : __byte_err_string_(_VSTD::move(__wc.__byte_err_string_)),
           __wide_err_string_(_VSTD::move(__wc.__wide_err_string_)),
           __cvtptr_(__wc.__cvtptr_),
-          __cvtstate_(__wc.__cvtstate_), __cvtcount_(__wc.__cvtstate_)
+          __cvtstate_(__wc.__cvtstate_), __cvtcount_(__wc.__cvtcount_)
 {
     __wc.__cvtptr_ = nullptr;
 }
@@ -4140,7 +3924,9 @@ wbuffer_convert<_Codecvt, _Elem, _Tr>::underflow()
         }
         else
         {
-            memmove(__extbuf_, __extbufnext_, __extbufend_ - __extbufnext_);
+             _LIBCPP_ASSERT(!(__extbufnext_ == NULL && (__extbufend_ != __extbufnext_)), "underflow moving from NULL" );
+             if (__extbufend_ != __extbufnext_)
+                memmove(__extbuf_, __extbufnext_, __extbufend_ - __extbufnext_);
             __extbufnext_ = __extbuf_ + (__extbufend_ - __extbufnext_);
             __extbufend_ = __extbuf_ + (__extbuf_ == __extbuf_min_ ? sizeof(__extbuf_min_) : __ebs_);
             streamsize __nmemb = _VSTD::min(static_cast<streamsize>(this->egptr() - this->eback() - __unget_sz),
diff --git a/include/map b/include/map
index 87add437a545..b8aa7a6d7a5d 100644
--- a/include/map
+++ b/include/map
@@ -162,7 +162,7 @@ public:
 
     void swap(map& m)
         noexcept(allocator_traits<allocator_type>::is_always_equal::value &&
-            __is_nothrow_swappable<key_compare>::value); // C++17
+            is_nothrow_swappable<key_compare>::value); // C++17
 
     // observers:
     allocator_type get_allocator() const noexcept;
@@ -357,7 +357,7 @@ public:
 
     void swap(multimap& m)
         noexcept(allocator_traits<allocator_type>::is_always_equal::value &&
-            __is_nothrow_swappable<key_compare>::value); // C++17
+            is_nothrow_swappable<key_compare>::value); // C++17
 
     // observers:
     allocator_type get_allocator() const noexcept;
@@ -564,13 +564,11 @@ class __map_node_destructor
 {
     typedef _Allocator                          allocator_type;
     typedef allocator_traits<allocator_type>    __alloc_traits;
-    typedef typename __alloc_traits::value_type::value_type value_type;
+
 public:
     typedef typename __alloc_traits::pointer    pointer;
-private:
-    typedef typename value_type::value_type::first_type     first_type;
-    typedef typename value_type::value_type::second_type    second_type;
 
+private:
     allocator_type& __na_;
 
     __map_node_destructor& operator=(const __map_node_destructor&);
@@ -615,7 +613,7 @@ template <class _Key, class _Tp, class _Compare, class _Allocator>
     class multimap;
 template <class _TreeIterator> class __map_const_iterator;
 
-#if __cplusplus >= 201103L
+#ifndef _LIBCPP_CXX03_LANG
 
 template <class _Key, class _Tp>
 union __value_type
@@ -628,33 +626,29 @@ union __value_type
     value_type __cc;
     __nc_value_type __nc;
 
-    template <class ..._Args>
-    _LIBCPP_INLINE_VISIBILITY
-    __value_type(_Args&& ...__args)
-        : __cc(std::forward<_Args>(__args)...) {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    __value_type(const __value_type& __v)
-        : __cc(__v.__cc) {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    __value_type(__value_type& __v)
-        : __cc(__v.__cc) {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    __value_type(__value_type&& __v)
-        : __nc(std::move(__v.__nc)) {}
-
     _LIBCPP_INLINE_VISIBILITY
     __value_type& operator=(const __value_type& __v)
         {__nc = __v.__cc; return *this;}
 
     _LIBCPP_INLINE_VISIBILITY
     __value_type& operator=(__value_type&& __v)
-        {__nc = std::move(__v.__nc); return *this;}
+        {__nc = _VSTD::move(__v.__nc); return *this;}
 
+    template <class _ValueTp,
+              class = typename enable_if<
+                    __is_same_uncvref<_ValueTp, value_type>::value
+                 >::type
+             >
     _LIBCPP_INLINE_VISIBILITY
-    ~__value_type() {__cc.~value_type();}
+    __value_type& operator=(_ValueTp&& __v) {
+        __nc = _VSTD::forward<_ValueTp>(__v); return *this;
+    }
+
+private:
+    __value_type() _LIBCPP_EQUAL_DELETE;
+    ~__value_type() _LIBCPP_EQUAL_DELETE;
+    __value_type(const __value_type& __v) _LIBCPP_EQUAL_DELETE;
+    __value_type(__value_type&& __v) _LIBCPP_EQUAL_DELETE;
 };
 
 #else
@@ -668,18 +662,11 @@ struct __value_type
 
     value_type __cc;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __value_type() {}
-
-    template <class _A0>
-    _LIBCPP_INLINE_VISIBILITY
-    __value_type(const _A0& __a0)
-        : __cc(__a0) {}
-
-    template <class _A0, class _A1>
-    _LIBCPP_INLINE_VISIBILITY
-    __value_type(const _A0& __a0, const _A1& __a1)
-        : __cc(__a0, __a1) {}
+private:
+   __value_type();
+   __value_type(__value_type const&);
+   __value_type& operator=(__value_type const&);
+   ~__value_type();
 };
 
 #endif
@@ -697,19 +684,17 @@ struct __extract_key_value_types<__value_type<_Key, _Tp> >
 template <class _TreeIterator>
 class _LIBCPP_TYPE_VIS_ONLY __map_iterator
 {
+    typedef typename _TreeIterator::_NodeTypes                   _NodeTypes;
+    typedef typename _TreeIterator::__pointer_traits             __pointer_traits;
+
     _TreeIterator __i_;
 
-    typedef typename _TreeIterator::__pointer_traits             __pointer_traits;
-    typedef typename _TreeIterator::value_type __value_type;
-    typedef typename __extract_key_value_types<__value_type>::__key_type    __key_type;
-    typedef typename __extract_key_value_types<__value_type>::__mapped_type __mapped_type;
 public:
     typedef bidirectional_iterator_tag                           iterator_category;
-    typedef pair<__key_type, __mapped_type>                      value_type;
+    typedef typename _NodeTypes::__map_value_type                value_type;
     typedef typename _TreeIterator::difference_type              difference_type;
     typedef value_type&                                          reference;
-    typedef typename __rebind_pointer<typename __pointer_traits::pointer, value_type>::type
-        pointer;
+    typedef typename _NodeTypes::__map_value_type_pointer        pointer;
 
     _LIBCPP_INLINE_VISIBILITY
     __map_iterator() _NOEXCEPT {}
@@ -758,19 +743,17 @@ public:
 template <class _TreeIterator>
 class _LIBCPP_TYPE_VIS_ONLY __map_const_iterator
 {
+    typedef typename _TreeIterator::_NodeTypes                   _NodeTypes;
+    typedef typename _TreeIterator::__pointer_traits             __pointer_traits;
+
     _TreeIterator __i_;
 
-    typedef typename _TreeIterator::__pointer_traits             __pointer_traits;
-    typedef typename _TreeIterator::value_type __value_type;
-    typedef typename __extract_key_value_types<__value_type>::__key_type    __key_type;
-    typedef typename __extract_key_value_types<__value_type>::__mapped_type __mapped_type;
 public:
     typedef bidirectional_iterator_tag                           iterator_category;
-    typedef pair<__key_type, __mapped_type>                      value_type;
+    typedef typename _NodeTypes::__map_value_type                value_type;
     typedef typename _TreeIterator::difference_type              difference_type;
     typedef const value_type&                                    reference;
-    typedef typename __rebind_pointer<typename __pointer_traits::pointer, const value_type>::type
-        pointer;
+    typedef typename _NodeTypes::__const_map_value_type_pointer  pointer;
 
     _LIBCPP_INLINE_VISIBILITY
     __map_const_iterator() _NOEXCEPT {}
@@ -927,7 +910,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     map& operator=(const map& __m)
         {
-#if __cplusplus >= 201103L
+#ifndef _LIBCPP_CXX03_LANG
             __tree_ = __m.__tree_;
 #else
             if (this != &__m) {
@@ -1043,7 +1026,7 @@ public:
     size_type max_size() const _NOEXCEPT {return __tree_.max_size();}
 
     mapped_type& operator[](const key_type& __k);
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifndef _LIBCPP_CXX03_LANG
     mapped_type& operator[](key_type&& __k);
 #endif
 
@@ -1057,18 +1040,18 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     value_compare  value_comp()    const {return value_compare(__tree_.value_comp().key_comp());}
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#ifndef _LIBCPP_HAS_NO_VARIADICS
-
+#ifndef _LIBCPP_CXX03_LANG
     template <class ..._Args>
-        pair<iterator, bool>
-        emplace(_Args&& ...__args);
+    _LIBCPP_INLINE_VISIBILITY
+    pair<iterator, bool> emplace(_Args&& ...__args) {
+        return __tree_.__emplace_unique(_VSTD::forward<_Args>(__args)...);
+    }
 
     template <class ..._Args>
-        iterator
-        emplace_hint(const_iterator __p, _Args&& ...__args);
-
-#endif  // _LIBCPP_HAS_NO_VARIADICS
+    _LIBCPP_INLINE_VISIBILITY
+    iterator emplace_hint(const_iterator __p, _Args&& ...__args) {
+        return __tree_.__emplace_hint_unique(__p.__i_, _VSTD::forward<_Args>(__args)...);
+    }
 
     template <class _Pp,
               class = typename enable_if<is_constructible<value_type, _Pp>::value>::type>
@@ -1082,7 +1065,7 @@ public:
         iterator insert(const_iterator __pos, _Pp&& __p)
             {return __tree_.__insert_unique(__pos.__i_, _VSTD::forward<_Pp>(__p));}
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif  // _LIBCPP_CXX03_LANG
 
     _LIBCPP_INLINE_VISIBILITY
     pair<iterator, bool>
@@ -1093,15 +1076,14 @@ public:
         insert(const_iterator __p, const value_type& __v)
             {return __tree_.__insert_unique(__p.__i_, __v);}
 
-#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
+#ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     pair<iterator, bool>
-        insert(     value_type&& __v) {return __tree_.__insert_unique(_VSTD::forward<value_type>(__v));}
+    insert(value_type&& __v) {return __tree_.__insert_unique(_VSTD::move(__v));}
 
     _LIBCPP_INLINE_VISIBILITY
-    iterator
-        insert(const_iterator __p,       value_type&& __v)
-            {return __tree_.__insert_unique(__p.__i_, _VSTD::forward<value_type>(__v));}
+    iterator insert(const_iterator __p,  value_type&& __v)
+    {return __tree_.__insert_unique(__p.__i_, _VSTD::move(__v));}
 #endif
 
     template <class _InputIterator>
@@ -1121,62 +1103,45 @@ public:
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
 #if _LIBCPP_STD_VER > 14
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#ifndef _LIBCPP_HAS_NO_VARIADICS
+
     template <class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         pair<iterator, bool> try_emplace(const key_type& __k, _Args&&... __args)
     {
-        iterator __p = lower_bound(__k);
-        if ( __p != end() && !key_comp()(__k, __p->first))
-            return _VSTD::make_pair(__p, false);
-        else
-            return _VSTD::make_pair(
-                      emplace_hint(__p, 
-                        _VSTD::piecewise_construct, _VSTD::forward_as_tuple(__k), 
-                        _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)),
-                      true);
+        return __tree_.__emplace_unique_key_args(__k,
+            _VSTD::piecewise_construct,
+            _VSTD::forward_as_tuple(__k),
+            _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...));
     }
 
     template <class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         pair<iterator, bool> try_emplace(key_type&& __k, _Args&&... __args)
     {
-        iterator __p = lower_bound(__k);
-        if ( __p != end() && !key_comp()(__k, __p->first))
-            return _VSTD::make_pair(__p, false);
-        else
-            return _VSTD::make_pair(
-                      emplace_hint(__p, 
-                        _VSTD::piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__k)), 
-                        _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)),
-                      true);
+        return __tree_.__emplace_unique_key_args(__k,
+            _VSTD::piecewise_construct,
+            _VSTD::forward_as_tuple(_VSTD::move(__k)),
+            _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...));
     }
 
     template <class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         iterator try_emplace(const_iterator __h, const key_type& __k, _Args&&... __args)
     {
-        iterator __p = lower_bound(__k);
-        if ( __p != end() && !key_comp()(__k, __p->first))
-            return __p;
-        else
-            return emplace_hint(__p, 
-                      _VSTD::piecewise_construct, _VSTD::forward_as_tuple(__k), 
-                      _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...));
+        return __tree_.__emplace_hint_unique_key_args(__h.__i_, __k,
+            _VSTD::piecewise_construct,
+            _VSTD::forward_as_tuple(__k),
+            _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...));
     }
 
     template <class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         iterator try_emplace(const_iterator __h, key_type&& __k, _Args&&... __args)
     {
-        iterator __p = lower_bound(__k);
-        if ( __p != end() && !key_comp()(__k, __p->first))
-            return __p;
-        else
-            return emplace_hint(__p, 
-                      _VSTD::piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__k)), 
-                      _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...));
+        return __tree_.__emplace_hint_unique_key_args(__h.__i_, __k,
+            _VSTD::piecewise_construct,
+            _VSTD::forward_as_tuple(_VSTD::move(__k)),
+            _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...));
     }
 
     template <class _Vp>
@@ -1191,7 +1156,7 @@ public:
         }
         return _VSTD::make_pair(emplace_hint(__p, __k, _VSTD::forward<_Vp>(__v)), true);
     }
-        
+
     template <class _Vp>
         _LIBCPP_INLINE_VISIBILITY
         pair<iterator, bool> insert_or_assign(key_type&& __k, _Vp&& __v)
@@ -1230,8 +1195,7 @@ public:
         }
         return emplace_hint(__h, _VSTD::move(__k), _VSTD::forward<_Vp>(__v));
      }
-#endif
-#endif
+
 #endif
 
     _LIBCPP_INLINE_VISIBILITY
@@ -1332,85 +1296,38 @@ private:
     typedef typename __base::__node                    __node;
     typedef typename __base::__node_allocator          __node_allocator;
     typedef typename __base::__node_pointer            __node_pointer;
-    typedef typename __base::__node_const_pointer      __node_const_pointer;
     typedef typename __base::__node_base_pointer       __node_base_pointer;
-    typedef typename __base::__node_base_const_pointer __node_base_const_pointer;
+
     typedef __map_node_destructor<__node_allocator> _Dp;
     typedef unique_ptr<__node, _Dp> __node_holder;
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    __node_holder __construct_node();
-    template <class _A0>
-        __node_holder __construct_node(_A0&& __a0);
-    __node_holder __construct_node_with_key(key_type&& __k);
-#ifndef _LIBCPP_HAS_NO_VARIADICS
-    template <class _A0, class _A1, class ..._Args>
-        __node_holder __construct_node(_A0&& __a0, _A1&& __a1, _Args&& ...__args);
-#endif  // _LIBCPP_HAS_NO_VARIADICS
-#endif
+#ifdef _LIBCPP_CXX03_LANG
     __node_holder __construct_node_with_key(const key_type& __k);
+#endif
+
+    __node_base_pointer const&
+    __find_equal_key(__node_base_pointer& __parent, const key_type& __k) const;
 
+    _LIBCPP_INLINE_VISIBILITY
     __node_base_pointer&
-        __find_equal_key(__node_base_pointer& __parent, const key_type& __k);
-    __node_base_const_pointer
-        __find_equal_key(__node_base_const_pointer& __parent, const key_type& __k) const;
+    __find_equal_key(__node_base_pointer& __parent, const key_type& __k) {
+        map const* __const_this = this;
+        return const_cast<__node_base_pointer&>(
+            __const_this->__find_equal_key(__parent, __k));
+    }
 };
 
-// Find place to insert if __k doesn't exist
-// Set __parent to parent of null leaf
-// Return reference to null leaf
-// If __k exists, set parent to node of __k and return reference to node of __k
-template <class _Key, class _Tp, class _Compare, class _Allocator>
-typename map<_Key, _Tp, _Compare, _Allocator>::__node_base_pointer&
-map<_Key, _Tp, _Compare, _Allocator>::__find_equal_key(__node_base_pointer& __parent,
-                                                       const key_type& __k)
-{
-    __node_pointer __nd = __tree_.__root();
-    if (__nd != nullptr)
-    {
-        while (true)
-        {
-            if (__tree_.value_comp().key_comp()(__k, __nd->__value_.__cc.first))
-            {
-                if (__nd->__left_ != nullptr)
-                    __nd = static_cast<__node_pointer>(__nd->__left_);
-                else
-                {
-                    __parent = static_cast<__node_base_pointer>(__nd);
-                    return __parent->__left_;
-                }
-            }
-            else if (__tree_.value_comp().key_comp()(__nd->__value_.__cc.first, __k))
-            {
-                if (__nd->__right_ != nullptr)
-                    __nd = static_cast<__node_pointer>(__nd->__right_);
-                else
-                {
-                    __parent = static_cast<__node_base_pointer>(__nd);
-                    return __parent->__right_;
-                }
-            }
-            else
-            {
-                __parent = static_cast<__node_base_pointer>(__nd);
-                return __parent;
-            }
-        }
-    }
-    __parent = static_cast<__node_base_pointer>(__tree_.__end_node());
-    return __parent->__left_;
-}
 
 // Find __k
 // Set __parent to parent of null leaf and
 //    return reference to null leaf iv __k does not exist.
 // If __k exists, set parent to node of __k and return reference to node of __k
 template <class _Key, class _Tp, class _Compare, class _Allocator>
-typename map<_Key, _Tp, _Compare, _Allocator>::__node_base_const_pointer
-map<_Key, _Tp, _Compare, _Allocator>::__find_equal_key(__node_base_const_pointer& __parent,
+typename map<_Key, _Tp, _Compare, _Allocator>::__node_base_pointer const&
+map<_Key, _Tp, _Compare, _Allocator>::__find_equal_key(__node_base_pointer& __parent,
                                                        const key_type& __k) const
 {
-    __node_const_pointer __nd = __tree_.__root();
+    __node_pointer __nd = __tree_.__root();
     if (__nd != nullptr)
     {
         while (true)
@@ -1422,7 +1339,7 @@ map<_Key, _Tp, _Compare, _Allocator>::__find_equal_key(__node_base_const_pointer
                 else
                 {
                     __parent = static_cast<__node_base_pointer>(__nd);
-                    return const_cast<const __node_base_const_pointer&>(__parent->__left_);
+                    return __parent->__left_;
                 }
             }
             else if (__tree_.value_comp().key_comp()(__nd->__value_.__cc.first, __k))
@@ -1432,7 +1349,7 @@ map<_Key, _Tp, _Compare, _Allocator>::__find_equal_key(__node_base_const_pointer
                 else
                 {
                     __parent = static_cast<__node_base_pointer>(__nd);
-                    return const_cast<const __node_base_const_pointer&>(__parent->__right_);
+                    return __parent->__right_;
                 }
             }
             else
@@ -1443,10 +1360,10 @@ map<_Key, _Tp, _Compare, _Allocator>::__find_equal_key(__node_base_const_pointer
         }
     }
     __parent = static_cast<__node_base_pointer>(__tree_.__end_node());
-    return const_cast<const __node_base_const_pointer&>(__parent->__left_);
+    return __parent->__left_;
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifndef _LIBCPP_CXX03_LANG
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
 map<_Key, _Tp, _Compare, _Allocator>::map(map&& __m, const allocator_type& __a)
@@ -1457,69 +1374,14 @@ map<_Key, _Tp, _Compare, _Allocator>::map(map&& __m, const allocator_type& __a)
         const_iterator __e = cend();
         while (!__m.empty())
             __tree_.__insert_unique(__e.__i_,
-                    _VSTD::move(__m.__tree_.remove(__m.begin().__i_)->__value_));
+                    _VSTD::move(__m.__tree_.remove(__m.begin().__i_)->__value_.__nc));
     }
 }
 
-template <class _Key, class _Tp, class _Compare, class _Allocator>
-typename map<_Key, _Tp, _Compare, _Allocator>::__node_holder
-map<_Key, _Tp, _Compare, _Allocator>::__construct_node()
-{
-    __node_allocator& __na = __tree_.__node_alloc();
-    __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
-    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__cc.first));
-    __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__cc.second));
-    __h.get_deleter().__second_constructed = true;
-    return __h;
-}
-
-template <class _Key, class _Tp, class _Compare, class _Allocator>
-template <class _A0>
-typename map<_Key, _Tp, _Compare, _Allocator>::__node_holder
-map<_Key, _Tp, _Compare, _Allocator>::__construct_node(_A0&& __a0)
-{
-    __node_allocator& __na = __tree_.__node_alloc();
-    __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
-    __node_traits::construct(__na, _VSTD::addressof(__h->__value_), _VSTD::forward<_A0>(__a0));
-    __h.get_deleter().__first_constructed = true;
-    __h.get_deleter().__second_constructed = true;
-    return __h;
-}
-
-template <class _Key, class _Tp, class _Compare, class _Allocator>
-typename map<_Key, _Tp, _Compare, _Allocator>::__node_holder
-map<_Key, _Tp, _Compare, _Allocator>::__construct_node_with_key(key_type&& __k)
-{
-    __node_allocator& __na = __tree_.__node_alloc();
-    __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
-    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__cc.first), _VSTD::move(__k));
-    __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__cc.second));
-    __h.get_deleter().__second_constructed = true;
-    return __h;
-}
-
-#ifndef _LIBCPP_HAS_NO_VARIADICS
+#endif  // !_LIBCPP_CXX03_LANG
 
-template <class _Key, class _Tp, class _Compare, class _Allocator>
-template <class _A0, class _A1, class ..._Args>
-typename map<_Key, _Tp, _Compare, _Allocator>::__node_holder
-map<_Key, _Tp, _Compare, _Allocator>::__construct_node(_A0&& __a0, _A1&& __a1, _Args&& ...__args)
-{
-    __node_allocator& __na = __tree_.__node_alloc();
-    __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
-    __node_traits::construct(__na, _VSTD::addressof(__h->__value_),
-                             _VSTD::forward<_A0>(__a0), _VSTD::forward<_A1>(__a1),
-                             _VSTD::forward<_Args>(__args)...);
-    __h.get_deleter().__first_constructed = true;
-    __h.get_deleter().__second_constructed = true;
-    return __h;
-}
 
-#endif  // _LIBCPP_HAS_NO_VARIADICS
-
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_CXX03_LANG
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
 typename map<_Key, _Tp, _Compare, _Allocator>::__node_holder
@@ -1550,25 +1412,29 @@ map<_Key, _Tp, _Compare, _Allocator>::operator[](const key_type& __k)
     return __r->__value_.__cc.second;
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#else
+
+template <class _Key, class _Tp, class _Compare, class _Allocator>
+_Tp&
+map<_Key, _Tp, _Compare, _Allocator>::operator[](const key_type& __k)
+{
+    return __tree_.__emplace_unique_key_args(__k,
+        _VSTD::piecewise_construct,
+        _VSTD::forward_as_tuple(__k),
+        _VSTD::forward_as_tuple()).first->__cc.second;
+}
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
 _Tp&
 map<_Key, _Tp, _Compare, _Allocator>::operator[](key_type&& __k)
 {
-    __node_base_pointer __parent;
-    __node_base_pointer& __child = __find_equal_key(__parent, __k);
-    __node_pointer __r = static_cast<__node_pointer>(__child);
-    if (__child == nullptr)
-    {
-        __node_holder __h = __construct_node_with_key(_VSTD::move(__k));
-        __tree_.__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
-        __r = __h.release();
-    }
-    return __r->__value_.__cc.second;
+    return __tree_.__emplace_unique_key_args(__k,
+        _VSTD::piecewise_construct,
+        _VSTD::forward_as_tuple(_VSTD::move(__k)),
+        _VSTD::forward_as_tuple()).first->__cc.second;
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif  // !_LIBCPP_CXX03_LANG
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
 _Tp&
@@ -1587,43 +1453,15 @@ template <class _Key, class _Tp, class _Compare, class _Allocator>
 const _Tp&
 map<_Key, _Tp, _Compare, _Allocator>::at(const key_type& __k) const
 {
-    __node_base_const_pointer __parent;
-    __node_base_const_pointer __child = __find_equal_key(__parent, __k);
+    __node_base_pointer __parent;
+    __node_base_pointer __child = __find_equal_key(__parent, __k);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (__child == nullptr)
         throw out_of_range("map::at:  key not found");
 #endif  // _LIBCPP_NO_EXCEPTIONS
-    return static_cast<__node_const_pointer>(__child)->__value_.__cc.second;
-}
-
-#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
-
-template <class _Key, class _Tp, class _Compare, class _Allocator>
-template <class ..._Args>
-pair<typename map<_Key, _Tp, _Compare, _Allocator>::iterator, bool>
-map<_Key, _Tp, _Compare, _Allocator>::emplace(_Args&& ...__args)
-{
-    __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
-    pair<iterator, bool> __r = __tree_.__node_insert_unique(__h.get());
-    if (__r.second)
-        __h.release();
-    return __r;
-}
-
-template <class _Key, class _Tp, class _Compare, class _Allocator>
-template <class ..._Args>
-typename map<_Key, _Tp, _Compare, _Allocator>::iterator
-map<_Key, _Tp, _Compare, _Allocator>::emplace_hint(const_iterator __p,
-                                                   _Args&& ...__args)
-{
-    __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
-    iterator __r = __tree_.__node_insert_unique(__p.__i_, __h.get());
-    if (__r.__i_.__ptr_ == __h.get())
-        __h.release();
-    return __r;
+    return static_cast<__node_pointer>(__child)->__value_.__cc.second;
 }
 
-#endif  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1799,7 +1637,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     multimap& operator=(const multimap& __m)
         {
-#if __cplusplus >= 201103L
+#ifndef _LIBCPP_CXX03_LANG
             __tree_ = __m.__tree_;
 #else
             if (this != &__m) {
@@ -1921,18 +1759,19 @@ public:
     value_compare  value_comp() const
         {return value_compare(__tree_.value_comp().key_comp());}
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#ifndef _LIBCPP_HAS_NO_VARIADICS
+#ifndef _LIBCPP_CXX03_LANG
 
     template <class ..._Args>
-        iterator
-        emplace(_Args&& ...__args);
+    _LIBCPP_INLINE_VISIBILITY
+    iterator emplace(_Args&& ...__args) {
+        return __tree_.__emplace_multi(_VSTD::forward<_Args>(__args)...);
+    }
 
     template <class ..._Args>
-        iterator
-        emplace_hint(const_iterator __p, _Args&& ...__args);
-
-#endif  // _LIBCPP_HAS_NO_VARIADICS
+    _LIBCPP_INLINE_VISIBILITY
+    iterator emplace_hint(const_iterator __p, _Args&& ...__args) {
+        return __tree_.__emplace_hint_multi(__p.__i_, _VSTD::forward<_Args>(__args)...);
+    }
 
     template <class _Pp,
               class = typename enable_if<is_constructible<value_type, _Pp>::value>::type>
@@ -1946,23 +1785,22 @@ public:
         iterator insert(const_iterator __pos, _Pp&& __p)
             {return __tree_.__insert_multi(__pos.__i_, _VSTD::forward<_Pp>(__p));}
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
     _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const value_type& __v) {return __tree_.__insert_multi(__v);}
+    iterator insert(value_type&& __v)
+        {return __tree_.__insert_multi(_VSTD::move(__v));}
 
     _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const_iterator __p, const value_type& __v)
-            {return __tree_.__insert_multi(__p.__i_, __v);}
+    iterator insert(const_iterator __p, value_type&& __v)
+        {return __tree_.__insert_multi(__p.__i_, _VSTD::move(__v));}
+
+#endif  // _LIBCPP_CXX03_LANG
 
-#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
     _LIBCPP_INLINE_VISIBILITY
-    iterator insert( value_type&& __v) {return __tree_.__insert_multi(_VSTD::forward<value_type>(__v));}
+    iterator insert(const value_type& __v) {return __tree_.__insert_multi(__v);}
 
     _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const_iterator __p, value_type&& __v)
-            {return __tree_.__insert_multi(__p.__i_, _VSTD::forward<value_type>(__v));}
-#endif
+    iterator insert(const_iterator __p, const value_type& __v)
+            {return __tree_.__insert_multi(__p.__i_, __v);}
 
     template <class _InputIterator>
         _LIBCPP_INLINE_VISIBILITY
@@ -2077,24 +1915,12 @@ private:
     typedef typename __base::__node                    __node;
     typedef typename __base::__node_allocator          __node_allocator;
     typedef typename __base::__node_pointer            __node_pointer;
-    typedef typename __base::__node_const_pointer      __node_const_pointer;
+
     typedef __map_node_destructor<__node_allocator> _Dp;
     typedef unique_ptr<__node, _Dp> __node_holder;
-
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    __node_holder __construct_node();
-    template <class _A0>
-        __node_holder
-         __construct_node(_A0&& __a0);
-#ifndef _LIBCPP_HAS_NO_VARIADICS
-    template <class _A0, class _A1, class ..._Args>
-        __node_holder __construct_node(_A0&& __a0, _A1&& __a1, _Args&& ...__args);
-#endif  // _LIBCPP_HAS_NO_VARIADICS
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 };
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
+#ifndef _LIBCPP_CXX03_LANG
 template <class _Key, class _Tp, class _Compare, class _Allocator>
 multimap<_Key, _Tp, _Compare, _Allocator>::multimap(multimap&& __m, const allocator_type& __a)
     : __tree_(_VSTD::move(__m.__tree_), __a)
@@ -2104,82 +1930,10 @@ multimap<_Key, _Tp, _Compare, _Allocator>::multimap(multimap&& __m, const alloca
         const_iterator __e = cend();
         while (!__m.empty())
             __tree_.__insert_multi(__e.__i_,
-                    _VSTD::move(__m.__tree_.remove(__m.begin().__i_)->__value_));
+                    _VSTD::move(__m.__tree_.remove(__m.begin().__i_)->__value_.__nc));
     }
 }
-
-template <class _Key, class _Tp, class _Compare, class _Allocator>
-typename multimap<_Key, _Tp, _Compare, _Allocator>::__node_holder
-multimap<_Key, _Tp, _Compare, _Allocator>::__construct_node()
-{
-    __node_allocator& __na = __tree_.__node_alloc();
-    __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
-    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__cc.first));
-    __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__cc.second));
-    __h.get_deleter().__second_constructed = true;
-    return __h;
-}
-
-template <class _Key, class _Tp, class _Compare, class _Allocator>
-template <class _A0>
-typename multimap<_Key, _Tp, _Compare, _Allocator>::__node_holder
-multimap<_Key, _Tp, _Compare, _Allocator>::__construct_node(_A0&& __a0)
-{
-    __node_allocator& __na = __tree_.__node_alloc();
-    __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
-    __node_traits::construct(__na, _VSTD::addressof(__h->__value_), _VSTD::forward<_A0>(__a0));
-    __h.get_deleter().__first_constructed = true;
-    __h.get_deleter().__second_constructed = true;
-    return __h;
-}
-
-#ifndef _LIBCPP_HAS_NO_VARIADICS
-
-template <class _Key, class _Tp, class _Compare, class _Allocator>
-template <class _A0, class _A1, class ..._Args>
-typename multimap<_Key, _Tp, _Compare, _Allocator>::__node_holder
-multimap<_Key, _Tp, _Compare, _Allocator>::__construct_node(_A0&& __a0, _A1&& __a1, _Args&& ...__args)
-{
-    __node_allocator& __na = __tree_.__node_alloc();
-    __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
-    __node_traits::construct(__na, _VSTD::addressof(__h->__value_),
-                             _VSTD::forward<_A0>(__a0), _VSTD::forward<_A1>(__a1),
-                             _VSTD::forward<_Args>(__args)...);
-    __h.get_deleter().__first_constructed = true;
-    __h.get_deleter().__second_constructed = true;
-    return __h;
-}
-
-#endif  // _LIBCPP_HAS_NO_VARIADICS
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
-#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
-
-template <class _Key, class _Tp, class _Compare, class _Allocator>
-template <class ..._Args>
-typename multimap<_Key, _Tp, _Compare, _Allocator>::iterator
-multimap<_Key, _Tp, _Compare, _Allocator>::emplace(_Args&& ...__args)
-{
-    __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
-    iterator __r = __tree_.__node_insert_multi(__h.get());
-    __h.release();
-    return __r;
-}
-
-template <class _Key, class _Tp, class _Compare, class _Allocator>
-template <class ..._Args>
-typename multimap<_Key, _Tp, _Compare, _Allocator>::iterator
-multimap<_Key, _Tp, _Compare, _Allocator>::emplace_hint(const_iterator __p,
-                                                        _Args&& ...__args)
-{
-    __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
-    iterator __r = __tree_.__node_insert_multi(__p.__i_, __h.get());
-    __h.release();
-    return __r;
-}
-
-#endif  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
+#endif
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
diff --git a/include/memory b/include/memory
index 3ef687c1774b..7a3281e17931 100644
--- a/include/memory
+++ b/include/memory
@@ -361,6 +361,7 @@ class shared_ptr
 {
 public:
     typedef T element_type;
+    typedef weak_ptr<T> weak_type; // C++17
 
     // constructors:
     constexpr shared_ptr() noexcept;
@@ -607,6 +608,7 @@ void* align(size_t alignment, size_t size, void*& ptr, size_t& space);
 #include <__functional_base>
 #include <iosfwd>
 #include <tuple>
+#include <stdexcept>
 #include <cstring>
 #if defined(_LIBCPP_NO_EXCEPTIONS)
     #include <cassert>
@@ -1726,7 +1728,12 @@ public:
     _LIBCPP_INLINE_VISIBILITY const_pointer address(const_reference __x) const _NOEXCEPT
         {return _VSTD::addressof(__x);}
     _LIBCPP_INLINE_VISIBILITY pointer allocate(size_type __n, allocator<void>::const_pointer = 0)
-        {return static_cast<pointer>(_VSTD::__allocate(__n * sizeof(_Tp)));}
+        {
+        if (__n > max_size())
+            __libcpp_throw(length_error("allocator<T>::allocate(size_t n)"
+                                      " 'n' exceeds maximum supported size"));
+        return static_cast<pointer>(_VSTD::__allocate(__n * sizeof(_Tp)));
+        }
     _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type) _NOEXCEPT
         {_VSTD::__deallocate((void*)__p);}
     _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT
@@ -1817,7 +1824,12 @@ public:
     _LIBCPP_INLINE_VISIBILITY const_pointer address(const_reference __x) const _NOEXCEPT
         {return _VSTD::addressof(__x);}
     _LIBCPP_INLINE_VISIBILITY pointer allocate(size_type __n, allocator<void>::const_pointer = 0)
-        {return static_cast<pointer>(_VSTD::__allocate(__n * sizeof(_Tp)));}
+    {
+        if (__n > max_size())
+            __libcpp_throw(length_error("allocator<const T>::allocate(size_t n)"
+                                      " 'n' exceeds maximum supported size"));
+        return static_cast<pointer>(_VSTD::__allocate(__n * sizeof(_Tp)));
+    }
     _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type) _NOEXCEPT
         {_VSTD::__deallocate((void*)__p);}
     _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT
@@ -2548,7 +2560,7 @@ public:
                          typename enable_if<__same_or_less_cv_qualified<_Up*, _Tp*>::value>::type* = 0) const _NOEXCEPT
         {
             static_assert(sizeof(_Tp) > 0, "default_delete can not delete incomplete type");
-            static_assert(!is_void<_Tp>::value, "default_delete can not delete incomplete type");
+            static_assert(!is_void<_Tp>::value, "default_delete can not delete void type");
             delete [] __ptr;
         }
 };
@@ -2918,7 +2930,6 @@ public:
         return __t;
     }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template <class _Pp>
     _LIBCPP_INLINE_VISIBILITY
     typename enable_if<__same_or_less_cv_qualified<_Pp, pointer>::value, void>::type
@@ -2929,29 +2940,13 @@ public:
         if (__tmp)
             __ptr_.second()(__tmp);
     }
-    _LIBCPP_INLINE_VISIBILITY void reset(nullptr_t) _NOEXCEPT
-    {
-        pointer __tmp = __ptr_.first();
-        __ptr_.first() = nullptr;
-        if (__tmp)
-            __ptr_.second()(__tmp);
-    }
-    _LIBCPP_INLINE_VISIBILITY void reset() _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY void reset(nullptr_t = nullptr) _NOEXCEPT
     {
         pointer __tmp = __ptr_.first();
         __ptr_.first() = nullptr;
         if (__tmp)
             __ptr_.second()(__tmp);
     }
-#else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY void reset(pointer __p = pointer())
-    {
-        pointer __tmp = __ptr_.first();
-        __ptr_.first() = __p;
-        if (__tmp)
-            __ptr_.second()(__tmp);
-    }
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     _LIBCPP_INLINE_VISIBILITY void swap(unique_ptr& __u) {__ptr_.swap(__u.__ptr_);}
 private:
@@ -2975,7 +2970,10 @@ private:
 
 template <class _Tp, class _Dp>
 inline _LIBCPP_INLINE_VISIBILITY
-void
+typename enable_if<
+    __is_swappable<_Dp>::value,
+    void
+>::type
 swap(unique_ptr<_Tp, _Dp>& __x, unique_ptr<_Tp, _Dp>& __y) _NOEXCEPT {__x.swap(__y);}
 
 template <class _T1, class _D1, class _T2, class _D2>
@@ -3167,8 +3165,6 @@ template<class _Tp, class... _Args>
 
 #endif  // _LIBCPP_STD_VER > 11
 
-template <class _Tp> struct hash;
-
 template <class _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 _Size
@@ -3868,6 +3864,9 @@ class _LIBCPP_TYPE_VIS_ONLY shared_ptr
 {
 public:
     typedef _Tp element_type;
+#if _LIBCPP_STD_VER > 14
+    typedef weak_ptr<_Tp> weak_type;
+#endif
 private:
     element_type*      __ptr_;
     __shared_weak_count* __cntrl_;
@@ -3979,23 +3978,23 @@ public:
         _LIBCPP_INLINE_VISIBILITY
         operator=(shared_ptr<_Yp>&& __r);
     template<class _Yp>
+        _LIBCPP_INLINE_VISIBILITY
         typename enable_if
         <
             !is_array<_Yp>::value &&
             is_convertible<_Yp*, element_type*>::value,
             shared_ptr
         >::type&
-        _LIBCPP_INLINE_VISIBILITY
         operator=(auto_ptr<_Yp>&& __r);
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template<class _Yp>
+        _LIBCPP_INLINE_VISIBILITY
         typename enable_if
         <
             !is_array<_Yp>::value &&
             is_convertible<_Yp*, element_type*>::value,
             shared_ptr&
         >::type
-        _LIBCPP_INLINE_VISIBILITY
         operator=(auto_ptr<_Yp> __r);
 #endif
     template <class _Yp, class _Dp>
@@ -4120,21 +4119,22 @@ public:
 
 private:
 
-    template <class _Yp>
+    template <class _Yp, class _OrigPtr>
         _LIBCPP_INLINE_VISIBILITY
         void
-        __enable_weak_this(const enable_shared_from_this<_Yp>* __e) _NOEXCEPT
+        __enable_weak_this(const enable_shared_from_this<_Yp>* __e,
+                           _OrigPtr* __ptr) _NOEXCEPT
         {
-            if (__e)
+            typedef typename remove_cv<_Yp>::type _RawYp;
+            if (__e && __e->__weak_this_.expired())
             {
-                __e->__weak_this_.__ptr_ = const_cast<_Yp*>(static_cast<const _Yp*>(__e));
-                __e->__weak_this_.__cntrl_ = __cntrl_;
-                __cntrl_->__add_weak();
+                __e->__weak_this_ = shared_ptr<_RawYp>(*this,
+                    const_cast<_RawYp*>(static_cast<const _Yp*>(__ptr)));
             }
         }
 
     _LIBCPP_INLINE_VISIBILITY
-    void __enable_weak_this(const volatile void*) _NOEXCEPT {}
+    void __enable_weak_this(const volatile void*, const volatile void*) _NOEXCEPT {}
 
     template <class _Up> friend class _LIBCPP_TYPE_VIS_ONLY shared_ptr;
     template <class _Up> friend class _LIBCPP_TYPE_VIS_ONLY weak_ptr;
@@ -4168,7 +4168,7 @@ shared_ptr<_Tp>::shared_ptr(_Yp* __p,
     typedef __shared_ptr_pointer<_Yp*, default_delete<_Yp>, allocator<_Yp> > _CntrlBlk;
     __cntrl_ = new _CntrlBlk(__p, default_delete<_Yp>(), allocator<_Yp>());
     __hold.release();
-    __enable_weak_this(__p);
+    __enable_weak_this(__p, __p);
 }
 
 template<class _Tp>
@@ -4183,7 +4183,7 @@ shared_ptr<_Tp>::shared_ptr(_Yp* __p, _Dp __d,
 #endif  // _LIBCPP_NO_EXCEPTIONS
         typedef __shared_ptr_pointer<_Yp*, _Dp, allocator<_Yp> > _CntrlBlk;
         __cntrl_ = new _CntrlBlk(__p, __d, allocator<_Yp>());
-        __enable_weak_this(__p);
+        __enable_weak_this(__p, __p);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
@@ -4233,7 +4233,7 @@ shared_ptr<_Tp>::shared_ptr(_Yp* __p, _Dp __d, _Alloc __a,
         ::new(static_cast<void*>(_VSTD::addressof(*__hold2.get())))
             _CntrlBlk(__p, __d, __a);
         __cntrl_ = _VSTD::addressof(*__hold2.release());
-        __enable_weak_this(__p);
+        __enable_weak_this(__p, __p);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
@@ -4344,7 +4344,7 @@ shared_ptr<_Tp>::shared_ptr(auto_ptr<_Yp> __r,
 {
     typedef __shared_ptr_pointer<_Yp*, default_delete<_Yp>, allocator<_Yp> > _CntrlBlk;
     __cntrl_ = new _CntrlBlk(__r.get(), default_delete<_Yp>(), allocator<_Yp>());
-    __enable_weak_this(__r.get());
+    __enable_weak_this(__r.get(), __r.get());
     __r.release();
 }
 
@@ -4372,7 +4372,7 @@ shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp> __r,
     {
         typedef __shared_ptr_pointer<_Yp*, _Dp, allocator<_Yp> > _CntrlBlk;
         __cntrl_ = new _CntrlBlk(__r.get(), __r.get_deleter(), allocator<_Yp>());
-        __enable_weak_this(__r.get());
+        __enable_weak_this(__r.get(), __r.get());
     }
     __r.release();
 }
@@ -4403,7 +4403,7 @@ shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp> __r,
                                      reference_wrapper<typename remove_reference<_Dp>::type>,
                                      allocator<_Yp> > _CntrlBlk;
         __cntrl_ = new _CntrlBlk(__r.get(), ref(__r.get_deleter()), allocator<_Yp>());
-        __enable_weak_this(__r.get());
+        __enable_weak_this(__r.get(), __r.get());
     }
     __r.release();
 }
@@ -4424,7 +4424,7 @@ shared_ptr<_Tp>::make_shared(_Args&& ...__args)
     shared_ptr<_Tp> __r;
     __r.__ptr_ = __hold2.get()->get();
     __r.__cntrl_ = __hold2.release();
-    __r.__enable_weak_this(__r.__ptr_);
+    __r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
     return __r;
 }
 
@@ -4443,7 +4443,7 @@ shared_ptr<_Tp>::allocate_shared(const _Alloc& __a, _Args&& ...__args)
     shared_ptr<_Tp> __r;
     __r.__ptr_ = __hold2.get()->get();
     __r.__cntrl_ = _VSTD::addressof(*__hold2.release());
-    __r.__enable_weak_this(__r.__ptr_);
+    __r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
     return __r;
 }
 
@@ -4462,7 +4462,7 @@ shared_ptr<_Tp>::make_shared()
     shared_ptr<_Tp> __r;
     __r.__ptr_ = __hold2.get()->get();
     __r.__cntrl_ = __hold2.release();
-    __r.__enable_weak_this(__r.__ptr_);
+    __r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
     return __r;
 }
 
@@ -4480,7 +4480,7 @@ shared_ptr<_Tp>::make_shared(_A0& __a0)
     shared_ptr<_Tp> __r;
     __r.__ptr_ = __hold2.get()->get();
     __r.__cntrl_ = __hold2.release();
-    __r.__enable_weak_this(__r.__ptr_);
+    __r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
     return __r;
 }
 
@@ -4498,7 +4498,7 @@ shared_ptr<_Tp>::make_shared(_A0& __a0, _A1& __a1)
     shared_ptr<_Tp> __r;
     __r.__ptr_ = __hold2.get()->get();
     __r.__cntrl_ = __hold2.release();
-    __r.__enable_weak_this(__r.__ptr_);
+    __r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
     return __r;
 }
 
@@ -4516,7 +4516,7 @@ shared_ptr<_Tp>::make_shared(_A0& __a0, _A1& __a1, _A2& __a2)
     shared_ptr<_Tp> __r;
     __r.__ptr_ = __hold2.get()->get();
     __r.__cntrl_ = __hold2.release();
-    __r.__enable_weak_this(__r.__ptr_);
+    __r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
     return __r;
 }
 
@@ -4535,7 +4535,7 @@ shared_ptr<_Tp>::allocate_shared(const _Alloc& __a)
     shared_ptr<_Tp> __r;
     __r.__ptr_ = __hold2.get()->get();
     __r.__cntrl_ = _VSTD::addressof(*__hold2.release());
-    __r.__enable_weak_this(__r.__ptr_);
+    __r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
     return __r;
 }
 
@@ -4554,7 +4554,7 @@ shared_ptr<_Tp>::allocate_shared(const _Alloc& __a, _A0& __a0)
     shared_ptr<_Tp> __r;
     __r.__ptr_ = __hold2.get()->get();
     __r.__cntrl_ = _VSTD::addressof(*__hold2.release());
-    __r.__enable_weak_this(__r.__ptr_);
+    __r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
     return __r;
 }
 
@@ -4573,7 +4573,7 @@ shared_ptr<_Tp>::allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1)
     shared_ptr<_Tp> __r;
     __r.__ptr_ = __hold2.get()->get();
     __r.__cntrl_ = _VSTD::addressof(*__hold2.release());
-    __r.__enable_weak_this(__r.__ptr_);
+    __r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
     return __r;
 }
 
@@ -4592,7 +4592,7 @@ shared_ptr<_Tp>::allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1, _A2& _
     shared_ptr<_Tp> __r;
     __r.__ptr_ = __hold2.get()->get();
     __r.__cntrl_ = _VSTD::addressof(*__hold2.release());
-    __r.__enable_weak_this(__r.__ptr_);
+    __r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
     return __r;
 }
 
@@ -5437,6 +5437,16 @@ public:
     shared_ptr<_Tp const> shared_from_this() const
         {return shared_ptr<const _Tp>(__weak_this_);}
 
+#if _LIBCPP_STD_VER > 14
+    _LIBCPP_INLINE_VISIBILITY
+    weak_ptr<_Tp> weak_from_this() _NOEXCEPT
+       { return __weak_this_; }
+
+    _LIBCPP_INLINE_VISIBILITY
+    weak_ptr<const _Tp> weak_from_this() const _NOEXCEPT
+        { return __weak_this_; }
+#endif // _LIBCPP_STD_VER > 14
+
     template <class _Up> friend class shared_ptr;
 };
 
@@ -5457,9 +5467,8 @@ inline _LIBCPP_INLINE_VISIBILITY
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p);
 
-// TODO(EricWF): Enable this for both Clang and GCC. Currently it is only
-// enabled with clang.
-#if defined(_LIBCPP_HAS_C_ATOMIC_IMP) && !defined(_LIBCPP_HAS_NO_THREADS)
+
+#if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
 
 class _LIBCPP_TYPE_VIS __sp_mut
 {
@@ -5546,14 +5555,17 @@ template <class _Tp>
 bool
 atomic_compare_exchange_strong(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w)
 {
+    shared_ptr<_Tp> __temp;
     __sp_mut& __m = __get_sp_mut(__p);
     __m.lock();
     if (__p->__owner_equivalent(*__v))
     {
+        _VSTD::swap(__temp, *__p);
         *__p = __w;
         __m.unlock();
         return true;
     }
+    _VSTD::swap(__temp, *__v);
     *__v = *__p;
     __m.unlock();
     return false;
@@ -5585,7 +5597,7 @@ atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v
     return atomic_compare_exchange_weak(__p, __v, __w);
 }
 
-#endif  // defined(_LIBCPP_HAS_C_ATOMIC_IMP) && !defined(_LIBCPP_HAS_NO_THREADS)
+#endif  // !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
 
 //enum class
 struct _LIBCPP_TYPE_VIS pointer_safety
@@ -5623,7 +5635,7 @@ _LIBCPP_FUNC_VIS void* align(size_t __align, size_t __sz, void*& __ptr, size_t&
 
 // --- Helper for container swap --
 template <typename _Alloc>
-_LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY
 void __swap_allocator(_Alloc & __a1, _Alloc & __a2)
 #if _LIBCPP_STD_VER >= 14
     _NOEXCEPT
@@ -5649,7 +5661,7 @@ void __swap_allocator(_Alloc & __a1, _Alloc & __a2, true_type)
 }
 
 template <typename _Alloc>
-_LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY
 void __swap_allocator(_Alloc &, _Alloc &, false_type) _NOEXCEPT {}
 
 template <typename _Alloc, typename _Traits=allocator_traits<_Alloc> >
@@ -5662,6 +5674,26 @@ struct __noexcept_move_assign_container : public integral_constant<bool,
 #endif
     > {};
 
+
+#ifndef _LIBCPP_HAS_NO_VARIADICS
+template <class _Tp, class _Alloc>
+struct __temp_value {
+    typedef allocator_traits<_Alloc> _Traits;
+    
+    typename aligned_storage<sizeof(_Tp), alignof(_Tp)>::type __v;
+    _Alloc &__a;
+
+    _Tp *__addr() { return reinterpret_cast<_Tp *>(addressof(__v)); }
+    _Tp &   get() { return *__addr(); }
+        
+    template<class... _Args>
+    __temp_value(_Alloc &__alloc, _Args&& ... __args) : __a(__alloc)
+    { _Traits::construct(__a, __addr(), _VSTD::forward<_Args>(__args)...); }
+    
+    ~__temp_value() { _Traits::destroy(__a, __addr()); }
+    };
+#endif
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_MEMORY
diff --git a/include/mutex b/include/mutex
index a0875a568ec6..c047cf943e8c 100644
--- a/include/mutex
+++ b/include/mutex
@@ -109,6 +109,19 @@ public:
     lock_guard& operator=(lock_guard const&) = delete;
 };
 
+template <class... MutexTypes> // Variadic lock_guard only provided in ABI V2.
+class lock_guard
+{
+public:
+    explicit lock_guard(MutexTypes&... m);
+    lock_guard(MutexTypes&... m, adopt_lock_t);
+    ~lock_guard();
+    lock_guard(lock_guard const&) = delete;
+    lock_guard& operator=(lock_guard const&) = delete;
+private:
+    tuple<MutexTypes&...> pm; // exposition only
+};
+
 template <class Mutex>
 class unique_lock
 {
@@ -179,9 +192,7 @@ template<class Callable, class ...Args>
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 #include <tuple>
 #endif
-#ifndef _LIBCPP_HAS_NO_THREADS
-#include <sched.h>
-#endif
+#include <__threading_support>
 
 #include <__undef_min_max>
 
@@ -195,7 +206,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 class _LIBCPP_TYPE_VIS recursive_mutex
 {
-    pthread_mutex_t __m_;
+    __libcpp_mutex_t __m_;
 
 public:
      recursive_mutex();
@@ -210,7 +221,7 @@ public:
     bool try_lock() _NOEXCEPT;
     void unlock()  _NOEXCEPT;
 
-    typedef pthread_mutex_t* native_handle_type;
+    typedef __libcpp_mutex_t* native_handle_type;
     _LIBCPP_INLINE_VISIBILITY
     native_handle_type native_handle() {return &__m_;}
 };
@@ -262,7 +273,7 @@ class _LIBCPP_TYPE_VIS recursive_timed_mutex
     mutex              __m_;
     condition_variable __cv_;
     size_t             __count_;
-    pthread_t          __id_;
+    __libcpp_thread_id __id_;
 public:
      recursive_timed_mutex();
      ~recursive_timed_mutex();
@@ -288,9 +299,9 @@ bool
 recursive_timed_mutex::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t)
 {
     using namespace chrono;
-    pthread_t __id = pthread_self();
+    __libcpp_thread_id __id = __libcpp_thread_get_current_id();
     unique_lock<mutex> lk(__m_);
-    if (pthread_equal(__id, __id_))
+    if (__libcpp_thread_id_equal(__id, __id_))
     {
         if (__count_ == numeric_limits<size_t>::max())
             return false;
@@ -362,7 +373,7 @@ lock(_L0& __l0, _L1& __l1)
                 break;
             }
         }
-        sched_yield();
+        __libcpp_thread_yield();
         {
             unique_lock<_L1> __u1(__l1);
             if (__l0.try_lock())
@@ -371,7 +382,7 @@ lock(_L0& __l0, _L1& __l1)
                 break;
             }
         }
-        sched_yield();
+        __libcpp_thread_yield();
     }
 }
 
@@ -396,7 +407,7 @@ __lock_first(int __i, _L0& __l0, _L1& __l1, _L2& __l2, _L3& ...__l3)
                 }
             }
             ++__i;
-            sched_yield();
+            __libcpp_thread_yield();
             break;
         case 1:
             {
@@ -412,7 +423,7 @@ __lock_first(int __i, _L0& __l0, _L1& __l1, _L2& __l2, _L3& ...__l3)
                 __i = 0;
             else
                 __i += 2;
-            sched_yield();
+            __libcpp_thread_yield();
             break;
         default:
             __lock_first(__i - 2, __l2, __l3..., __l0, __l1);
@@ -429,6 +440,27 @@ lock(_L0& __l0, _L1& __l1, _L2& __l2, _L3& ...__l3)
     __lock_first(0, __l0, __l1, __l2, __l3...);
 }
 
+template <class _L0>
+inline _LIBCPP_INLINE_VISIBILITY
+void __unlock(_L0& __l0) {
+    __l0.unlock();
+}
+
+template <class _L0, class _L1>
+inline _LIBCPP_INLINE_VISIBILITY
+void __unlock(_L0& __l0, _L1& __l1) {
+    __l0.unlock();
+    __l1.unlock();
+}
+
+template <class _L0, class _L1, class _L2, class ..._L3>
+inline _LIBCPP_INLINE_VISIBILITY
+void __unlock(_L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3) {
+    __l0.unlock();
+    __l1.unlock();
+    _VSTD::__unlock(__l2, __l3...);
+}
+
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
 #endif // !_LIBCPP_HAS_NO_THREADS
@@ -579,6 +611,63 @@ call_once(once_flag& __flag, const _Callable& __func)
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
+
+#if defined(_LIBCPP_ABI_VARIADIC_LOCK_GUARD) \
+    && !defined(_LIBCPP_CXX03_LANG)
+template <>
+class _LIBCPP_TYPE_VIS_ONLY lock_guard<> {
+public:
+    explicit lock_guard() {}
+    ~lock_guard() = default;
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit lock_guard(adopt_lock_t) {}
+
+    lock_guard(lock_guard const&) = delete;
+    lock_guard& operator=(lock_guard const&) = delete;
+};
+
+template <class ..._MArgs>
+class _LIBCPP_TYPE_VIS_ONLY lock_guard
+{
+    static_assert(sizeof...(_MArgs) >= 2, "At least 2 lock types required");
+    typedef tuple<_MArgs&...> _MutexTuple;
+
+public:
+    _LIBCPP_INLINE_VISIBILITY
+    explicit lock_guard(_MArgs&... __margs)
+      : __t_(__margs...)
+    {
+        _VSTD::lock(__margs...);
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    lock_guard(_MArgs&... __margs, adopt_lock_t)
+        : __t_(__margs...)
+    {
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    ~lock_guard() {
+        typedef typename __make_tuple_indices<sizeof...(_MArgs)>::type _Indices;
+        __unlock_unpack(_Indices{}, __t_);
+    }
+
+    lock_guard(lock_guard const&) = delete;
+    lock_guard& operator=(lock_guard const&) = delete;
+
+private:
+    template <size_t ..._Indx>
+    _LIBCPP_INLINE_VISIBILITY
+    static void __unlock_unpack(__tuple_indices<_Indx...>, _MutexTuple& __mt) {
+        _VSTD::__unlock(_VSTD::get<_Indx>(__mt)...);
+    }
+
+    _MutexTuple __t_;
+};
+
+#endif // _LIBCPP_ABI_VARIADIC_LOCK_GUARD
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_MUTEX
diff --git a/include/queue b/include/queue
index 6f49c87acdc5..c657b52f8038 100644
--- a/include/queue
+++ b/include/queue
@@ -66,7 +66,7 @@ public:
     template <class... Args> void emplace(Args&&... args);
     void pop();
 
-    void swap(queue& q) noexcept(noexcept(swap(c, q.c)));
+    void swap(queue& q) noexcept(is_nothrow_swappable_v<Container>)
 };
 
 template <class T, class Container>
@@ -153,7 +153,8 @@ public:
     void pop();
 
     void swap(priority_queue& q)
-        noexcept(noexcept(swap(c, q.c)) && noexcept(swap(comp.q.comp)));
+        noexcept(is_nothrow_swappable_v<Container> &&
+                 is_nothrow_swappable_v<Comp>)
 };
 
 template <class T, class Container, class Compare>
@@ -198,6 +199,7 @@ public:
     typedef typename container_type::reference       reference;
     typedef typename container_type::const_reference const_reference;
     typedef typename container_type::size_type       size_type;
+    static_assert((is_same<_Tp, value_type>::value), "" );
 
 protected:
     container_type c;
@@ -368,7 +370,10 @@ operator<=(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
 
 template <class _Tp, class _Container>
 inline _LIBCPP_INLINE_VISIBILITY
-void
+typename enable_if<
+    __is_swappable<_Container>::value,
+    void
+>::type
 swap(queue<_Tp, _Container>& __x, queue<_Tp, _Container>& __y)
     _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
@@ -392,6 +397,7 @@ public:
     typedef typename container_type::reference       reference;
     typedef typename container_type::const_reference const_reference;
     typedef typename container_type::size_type       size_type;
+    static_assert((is_same<_Tp, value_type>::value), "" );
 
 protected:
     container_type c;
@@ -430,45 +436,56 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     explicit priority_queue(const value_compare& __comp)
         : c(), comp(__comp) {}
+    _LIBCPP_INLINE_VISIBILITY
     priority_queue(const value_compare& __comp, const container_type& __c);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     explicit priority_queue(const value_compare& __comp, container_type&& __c);
 #endif
     template <class _InputIter>
+        _LIBCPP_INLINE_VISIBILITY
         priority_queue(_InputIter __f, _InputIter __l,
                        const value_compare& __comp = value_compare());
     template <class _InputIter>
+        _LIBCPP_INLINE_VISIBILITY
         priority_queue(_InputIter __f, _InputIter __l,
                        const value_compare& __comp, const container_type& __c);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template <class _InputIter>
+        _LIBCPP_INLINE_VISIBILITY
         priority_queue(_InputIter __f, _InputIter __l,
                        const value_compare& __comp, container_type&& __c);
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template <class _Alloc>
+        _LIBCPP_INLINE_VISIBILITY
         explicit priority_queue(const _Alloc& __a,
                        typename enable_if<uses_allocator<container_type,
                                                          _Alloc>::value>::type* = 0);
     template <class _Alloc>
+        _LIBCPP_INLINE_VISIBILITY
         priority_queue(const value_compare& __comp, const _Alloc& __a,
                        typename enable_if<uses_allocator<container_type,
                                                          _Alloc>::value>::type* = 0);
     template <class _Alloc>
+        _LIBCPP_INLINE_VISIBILITY
         priority_queue(const value_compare& __comp, const container_type& __c,
                        const _Alloc& __a,
                        typename enable_if<uses_allocator<container_type,
                                                          _Alloc>::value>::type* = 0);
     template <class _Alloc>
+        _LIBCPP_INLINE_VISIBILITY
         priority_queue(const priority_queue& __q, const _Alloc& __a,
                        typename enable_if<uses_allocator<container_type,
                                                          _Alloc>::value>::type* = 0);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template <class _Alloc>
+        _LIBCPP_INLINE_VISIBILITY
         priority_queue(const value_compare& __comp, container_type&& __c,
                        const _Alloc& __a,
                        typename enable_if<uses_allocator<container_type,
                                                          _Alloc>::value>::type* = 0);
     template <class _Alloc>
+        _LIBCPP_INLINE_VISIBILITY
         priority_queue(priority_queue&& __q, const _Alloc& __a,
                        typename enable_if<uses_allocator<container_type,
                                                          _Alloc>::value>::type* = 0);
@@ -481,22 +498,26 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     const_reference top() const   {return c.front();}
 
+    _LIBCPP_INLINE_VISIBILITY
     void push(const value_type& __v);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     void push(value_type&& __v);
 #ifndef _LIBCPP_HAS_NO_VARIADICS
-    template <class... _Args> void emplace(_Args&&... __args);
+    template <class... _Args> _LIBCPP_INLINE_VISIBILITY void emplace(_Args&&... __args);
 #endif
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     void pop();
 
+    _LIBCPP_INLINE_VISIBILITY
     void swap(priority_queue& __q)
         _NOEXCEPT_(__is_nothrow_swappable<container_type>::value &&
                    __is_nothrow_swappable<value_compare>::value);
 };
 
 template <class _Tp, class _Container, class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 priority_queue<_Tp, _Container, _Compare>::priority_queue(const _Compare& __comp,
                                                           const container_type& __c)
     : c(__c),
@@ -508,7 +529,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(const _Compare& __comp
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Tp, class _Container, class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& __comp,
                                                           container_type&& __c)
     : c(_VSTD::move(__c)),
@@ -521,7 +542,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& _
 
 template <class _Tp, class _Container, class _Compare>
 template <class _InputIter>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _InputIter __l,
                                                           const value_compare& __comp)
     : c(__f, __l),
@@ -532,7 +553,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _Input
 
 template <class _Tp, class _Container, class _Compare>
 template <class _InputIter>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _InputIter __l,
                                                           const value_compare& __comp,
                                                           const container_type& __c)
@@ -547,7 +568,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _Input
 
 template <class _Tp, class _Container, class _Compare>
 template <class _InputIter>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _InputIter __l,
                                                           const value_compare& __comp,
                                                           container_type&& __c)
@@ -562,7 +583,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _Input
 
 template <class _Tp, class _Container, class _Compare>
 template <class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 priority_queue<_Tp, _Container, _Compare>::priority_queue(const _Alloc& __a,
                        typename enable_if<uses_allocator<container_type,
                                                          _Alloc>::value>::type*)
@@ -572,7 +593,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(const _Alloc& __a,
 
 template <class _Tp, class _Container, class _Compare>
 template <class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& __comp,
                                                           const _Alloc& __a,
                        typename enable_if<uses_allocator<container_type,
@@ -584,7 +605,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& _
 
 template <class _Tp, class _Container, class _Compare>
 template <class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& __comp,
                                                           const container_type& __c,
                                                           const _Alloc& __a,
@@ -598,7 +619,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& _
 
 template <class _Tp, class _Container, class _Compare>
 template <class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 priority_queue<_Tp, _Container, _Compare>::priority_queue(const priority_queue& __q,
                                                           const _Alloc& __a,
                        typename enable_if<uses_allocator<container_type,
@@ -613,7 +634,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(const priority_queue&
 
 template <class _Tp, class _Container, class _Compare>
 template <class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& __comp,
                                                           container_type&& __c,
                                                           const _Alloc& __a,
@@ -627,7 +648,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& _
 
 template <class _Tp, class _Container, class _Compare>
 template <class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 priority_queue<_Tp, _Container, _Compare>::priority_queue(priority_queue&& __q,
                                                           const _Alloc& __a,
                        typename enable_if<uses_allocator<container_type,
@@ -641,7 +662,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(priority_queue&& __q,
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Tp, class _Container, class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 priority_queue<_Tp, _Container, _Compare>::push(const value_type& __v)
 {
@@ -652,7 +673,7 @@ priority_queue<_Tp, _Container, _Compare>::push(const value_type& __v)
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Tp, class _Container, class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 priority_queue<_Tp, _Container, _Compare>::push(value_type&& __v)
 {
@@ -664,7 +685,7 @@ priority_queue<_Tp, _Container, _Compare>::push(value_type&& __v)
 
 template <class _Tp, class _Container, class _Compare>
 template <class... _Args>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 priority_queue<_Tp, _Container, _Compare>::emplace(_Args&&... __args)
 {
@@ -676,7 +697,7 @@ priority_queue<_Tp, _Container, _Compare>::emplace(_Args&&... __args)
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Tp, class _Container, class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 priority_queue<_Tp, _Container, _Compare>::pop()
 {
@@ -685,7 +706,7 @@ priority_queue<_Tp, _Container, _Compare>::pop()
 }
 
 template <class _Tp, class _Container, class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 priority_queue<_Tp, _Container, _Compare>::swap(priority_queue& __q)
         _NOEXCEPT_(__is_nothrow_swappable<container_type>::value &&
@@ -698,7 +719,11 @@ priority_queue<_Tp, _Container, _Compare>::swap(priority_queue& __q)
 
 template <class _Tp, class _Container, class _Compare>
 inline _LIBCPP_INLINE_VISIBILITY
-void
+typename enable_if<
+    __is_swappable<_Container>::value
+    && __is_swappable<_Compare>::value,
+    void
+>::type
 swap(priority_queue<_Tp, _Container, _Compare>& __x,
      priority_queue<_Tp, _Container, _Compare>& __y)
     _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
diff --git a/include/shared_mutex b/include/shared_mutex
index dcb93949e30d..923fe07ab38b 100644
--- a/include/shared_mutex
+++ b/include/shared_mutex
@@ -319,25 +319,25 @@ public:
 
     _LIBCPP_INLINE_VISIBILITY
     explicit shared_lock(mutex_type& __m)
-        : __m_(&__m),
+        : __m_(_VSTD::addressof(__m)),
           __owns_(true)
         {__m_->lock_shared();}
 
     _LIBCPP_INLINE_VISIBILITY
     shared_lock(mutex_type& __m, defer_lock_t) _NOEXCEPT
-        : __m_(&__m),
+        : __m_(_VSTD::addressof(__m)),
           __owns_(false)
         {}
 
     _LIBCPP_INLINE_VISIBILITY
     shared_lock(mutex_type& __m, try_to_lock_t)
-        : __m_(&__m),
+        : __m_(_VSTD::addressof(__m)),
           __owns_(__m.try_lock_shared())
         {}
 
     _LIBCPP_INLINE_VISIBILITY
     shared_lock(mutex_type& __m, adopt_lock_t)
-        : __m_(&__m),
+        : __m_(_VSTD::addressof(__m)),
           __owns_(true)
         {}
 
@@ -345,7 +345,7 @@ public:
         _LIBCPP_INLINE_VISIBILITY
         shared_lock(mutex_type& __m,
                     const chrono::time_point<_Clock, _Duration>& __abs_time)
-            : __m_(&__m),
+            : __m_(_VSTD::addressof(__m)),
               __owns_(__m.try_lock_shared_until(__abs_time))
             {}
 
@@ -353,7 +353,7 @@ public:
         _LIBCPP_INLINE_VISIBILITY
         shared_lock(mutex_type& __m,
                     const chrono::duration<_Rep, _Period>& __rel_time)
-            : __m_(&__m),
+            : __m_(_VSTD::addressof(__m)),
               __owns_(__m.try_lock_shared_for(__rel_time))
             {}
 
diff --git a/include/stack b/include/stack
index 2992b091ee51..48b3b0d16ec2 100644
--- a/include/stack
+++ b/include/stack
@@ -58,7 +58,7 @@ public:
     template <class... Args> void emplace(Args&&... args);
     void pop();
 
-    void swap(stack& c) noexcept(noexcept(swap(c, q.c)));
+    void swap(stack& c) noexcept(is_nothrow_swappable_v<Container>)
 };
 
 template <class T, class Container>
@@ -112,7 +112,8 @@ public:
     typedef typename container_type::reference       reference;
     typedef typename container_type::const_reference const_reference;
     typedef typename container_type::size_type       size_type;
-
+    static_assert((is_same<_Tp, value_type>::value), "" );
+    
 protected:
     container_type c;
 
@@ -274,7 +275,10 @@ operator<=(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
 
 template <class _Tp, class _Container>
 inline _LIBCPP_INLINE_VISIBILITY
-void
+typename enable_if<
+    __is_swappable<_Container>::value,
+    void
+>::type
 swap(stack<_Tp, _Container>& __x, stack<_Tp, _Container>& __y)
     _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
diff --git a/include/stdbool.h b/include/stdbool.h
new file mode 100644
index 000000000000..86a127f0fd62
--- /dev/null
+++ b/include/stdbool.h
@@ -0,0 +1,39 @@
+// -*- C++ -*-
+//===--------------------------- stdbool.h --------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+#ifndef _LIBCPP_STDBOOL_H
+#define _LIBCPP_STDBOOL_H
+
+
+/*
+    stdbool.h synopsis
+
+Macros:
+
+    __bool_true_false_are_defined
+
+*/
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+#include_next <stdbool.h>
+
+#ifdef __cplusplus
+#undef bool
+#undef true
+#undef false
+#undef __bool_true_false_are_defined
+#define __bool_true_false_are_defined 1
+#endif
+
+#endif  // _LIBCPP_STDBOOL_H
diff --git a/include/stdexcept b/include/stdexcept
index f251806fba62..4218b1398d85 100644
--- a/include/stdexcept
+++ b/include/stdexcept
@@ -53,7 +53,11 @@ public:
 #ifndef _LIBCPP___REFSTRING
 _LIBCPP_BEGIN_NAMESPACE_STD
 class _LIBCPP_HIDDEN __libcpp_refstring {
-    const char *__imp_ _LIBCPP_UNUSED;
+#ifdef __clang__
+    const char *__imp_ __attribute__((__unused__)); // only clang emits a warning
+#else
+    const char *__imp_;
+#endif
 };
 _LIBCPP_END_NAMESPACE_STD
 #endif
diff --git a/include/streambuf b/include/streambuf
index 603c68038796..7544aaf179bd 100644
--- a/include/streambuf
+++ b/include/streambuf
@@ -495,12 +495,22 @@ basic_streambuf<_CharT, _Traits>::xsgetn(char_type* __s, streamsize __n)
     const int_type __eof = traits_type::eof();
     int_type __c;
     streamsize __i = 0;
-    for (;__i < __n; ++__i, ++__s)
+    while(__i < __n)
     {
         if (__ninp_ < __einp_)
-            *__s = *__ninp_++;
+        {
+            const streamsize __len = _VSTD::min(__einp_ - __ninp_, __n - __i);
+            traits_type::copy(__s, __ninp_, __len);
+            __s +=  __len;
+            __i +=  __len;
+            this->gbump(__len);
+        }
         else if ((__c = uflow()) != __eof)
+        {
             *__s = traits_type::to_char_type(__c);
+            ++__s;
+            ++__i;
+        }
         else
             break;
     }
diff --git a/include/string b/include/string
index 91502441e0c0..786735f970f8 100644
--- a/include/string
+++ b/include/string
@@ -98,8 +98,10 @@ public:
     basic_string(const basic_string& str);
     basic_string(basic_string&& str)
         noexcept(is_nothrow_move_constructible<allocator_type>::value);
-    basic_string(const basic_string& str, size_type pos, size_type n = npos,
+    basic_string(const basic_string& str, size_type pos,
                  const allocator_type& a = allocator_type());
+    basic_string(const basic_string& str, size_type pos, size_type n,
+                 const Allocator& a = Allocator());             
     basic_string(const value_type* s, const allocator_type& a = allocator_type());
     basic_string(const value_type* s, size_type n, const allocator_type& a = allocator_type());
     basic_string(size_type n, value_type c, const allocator_type& a = allocator_type());
@@ -225,6 +227,7 @@ public:
 
     const value_type* c_str() const noexcept;
     const value_type* data() const noexcept;
+          value_type* data()       noexcept;   // C++17
 
     allocator_type get_allocator() const noexcept;
 
@@ -958,7 +961,7 @@ char_traits<char32_t>::assign(char_type* __s, size_t __n, char_type __a)
 
 // __str_find
 template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
-_SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 __str_find(const _CharT *__p, _SizeT __sz, 
              _CharT __c, _SizeT __pos) _NOEXCEPT
 {
@@ -971,7 +974,7 @@ __str_find(const _CharT *__p, _SizeT __sz,
 }
 
 template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
-_SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 __str_find(const _CharT *__p, _SizeT __sz, 
        const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT
 {
@@ -982,7 +985,7 @@ __str_find(const _CharT *__p, _SizeT __sz,
     const _CharT* __r = 
         _VSTD::__search(__p + __pos, __p + __sz,
                         __s, __s + __n, _Traits::eq,
-                        random_access_iterator_tag(), random_access_iterator_tag());
+                        random_access_iterator_tag(), random_access_iterator_tag()).first;
     if (__r == __p + __sz)
         return __npos;
     return static_cast<_SizeT>(__r - __p);
@@ -992,7 +995,7 @@ __str_find(const _CharT *__p, _SizeT __sz,
 // __str_rfind
 
 template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
-_SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 __str_rfind(const _CharT *__p, _SizeT __sz, 
               _CharT __c, _SizeT __pos) _NOEXCEPT
 {
@@ -1011,7 +1014,7 @@ __str_rfind(const _CharT *__p, _SizeT __sz,
 }
 
 template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
-_SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 __str_rfind(const _CharT *__p, _SizeT __sz, 
         const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT
 {
@@ -1030,7 +1033,7 @@ __str_rfind(const _CharT *__p, _SizeT __sz,
 
 // __str_find_first_of
 template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
-_SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 __str_find_first_of(const _CharT *__p, _SizeT __sz,
                 const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT
 {
@@ -1046,7 +1049,7 @@ __str_find_first_of(const _CharT *__p, _SizeT __sz,
 
 // __str_find_last_of
 template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
-_SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 
+inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 __str_find_last_of(const _CharT *__p, _SizeT __sz,
                const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT
     {
@@ -1069,7 +1072,7 @@ __str_find_last_of(const _CharT *__p, _SizeT __sz,
 
 // __str_find_first_not_of
 template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
-_SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 __str_find_first_not_of(const _CharT *__p, _SizeT __sz,
                     const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT
 {
@@ -1085,7 +1088,7 @@ __str_find_first_not_of(const _CharT *__p, _SizeT __sz,
 
 
 template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
-_SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 __str_find_first_not_of(const _CharT *__p, _SizeT __sz,
                           _CharT __c, _SizeT __pos) _NOEXCEPT
 {
@@ -1102,7 +1105,7 @@ __str_find_first_not_of(const _CharT *__p, _SizeT __sz,
 
 // __str_find_last_not_of
 template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
-_SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 __str_find_last_not_of(const _CharT *__p, _SizeT __sz,
                    const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT
 {
@@ -1118,7 +1121,7 @@ __str_find_last_not_of(const _CharT *__p, _SizeT __sz,
 
 
 template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
-_SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 __str_find_last_not_of(const _CharT *__p, _SizeT __sz,
                          _CharT __c, _SizeT __pos) _NOEXCEPT
 {
@@ -1396,7 +1399,10 @@ public:
     basic_string(size_type __n, value_type __c);
     _LIBCPP_INLINE_VISIBILITY
     basic_string(size_type __n, value_type __c, const allocator_type& __a);
-    basic_string(const basic_string& __str, size_type __pos, size_type __n = npos,
+    basic_string(const basic_string& __str, size_type __pos, size_type __n,
+                 const allocator_type& __a = allocator_type());
+    _LIBCPP_INLINE_VISIBILITY
+    basic_string(const basic_string& __str, size_type __pos,
                  const allocator_type& __a = allocator_type());
     template<class _InputIterator>
         _LIBCPP_INLINE_VISIBILITY
@@ -1546,7 +1552,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY const_reference back() const;
 
     _LIBCPP_INLINE_VISIBILITY
-    basic_string& assign(const basic_string& __str);
+    basic_string& assign(const basic_string& __str) { return *this = __str; }
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     basic_string& assign(basic_string&& str)
@@ -1659,6 +1665,10 @@ public:
     const value_type* c_str() const _NOEXCEPT {return data();}
     _LIBCPP_INLINE_VISIBILITY
     const value_type* data() const _NOEXCEPT  {return _VSTD::__to_raw_pointer(__get_pointer());}
+#if _LIBCPP_STD_VER > 14
+    _LIBCPP_INLINE_VISIBILITY
+    value_type* data()             _NOEXCEPT  {return _VSTD::__to_raw_pointer(__get_pointer());}
+#endif
 
     _LIBCPP_INLINE_VISIBILITY
     allocator_type get_allocator() const _NOEXCEPT {return __alloc();}
@@ -2218,6 +2228,21 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __st
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_INLINE_VISIBILITY
+basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str, size_type __pos,
+                                                        const allocator_type& __a)
+    : __r_(__a)
+{
+    size_type __str_sz = __str.size();
+    if (__pos > __str_sz)
+        this->__throw_out_of_range();
+    __init(__str.data() + __pos, __str_sz - __pos);
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    __get_db()->__insert_c(this);
+#endif
+}
+
+template <class _CharT, class _Traits, class _Allocator>
 template <class _InputIterator>
 typename enable_if
 <
@@ -2466,7 +2491,7 @@ basic_string<_CharT, _Traits, _Allocator>::operator=(const basic_string& __str)
     if (this != &__str)
     {
         __copy_assign_alloc(__str);
-        assign(__str);
+        assign(__str.data(), __str.size());
     }
     return *this;
 }
@@ -2558,14 +2583,6 @@ basic_string<_CharT, _Traits, _Allocator>::assign(_ForwardIterator __first, _For
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::assign(const basic_string& __str)
-{
-    return assign(__str.data(), __str.size());
-}
-
-template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::assign(const basic_string& __str, size_type __pos, size_type __n)
 {
diff --git a/include/string.h b/include/string.h
new file mode 100644
index 000000000000..a1ce56cbcd6d
--- /dev/null
+++ b/include/string.h
@@ -0,0 +1,110 @@
+// -*- C++ -*-
+//===--------------------------- string.h ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_STRING_H
+#define _LIBCPP_STRING_H
+
+/*
+    string.h synopsis
+
+Macros:
+
+    NULL
+
+Types:
+
+    size_t
+
+void* memcpy(void* restrict s1, const void* restrict s2, size_t n);
+void* memmove(void* s1, const void* s2, size_t n);
+char* strcpy (char* restrict s1, const char* restrict s2);
+char* strncpy(char* restrict s1, const char* restrict s2, size_t n);
+char* strcat (char* restrict s1, const char* restrict s2);
+char* strncat(char* restrict s1, const char* restrict s2, size_t n);
+int memcmp(const void* s1, const void* s2, size_t n);
+int strcmp (const char* s1, const char* s2);
+int strncmp(const char* s1, const char* s2, size_t n);
+int strcoll(const char* s1, const char* s2);
+size_t strxfrm(char* restrict s1, const char* restrict s2, size_t n);
+const void* memchr(const void* s, int c, size_t n);
+      void* memchr(      void* s, int c, size_t n);
+const char* strchr(const char* s, int c);
+      char* strchr(      char* s, int c);
+size_t strcspn(const char* s1, const char* s2);
+const char* strpbrk(const char* s1, const char* s2);
+      char* strpbrk(      char* s1, const char* s2);
+const char* strrchr(const char* s, int c);
+      char* strrchr(      char* s, int c);
+size_t strspn(const char* s1, const char* s2);
+const char* strstr(const char* s1, const char* s2);
+      char* strstr(      char* s1, const char* s2);
+char* strtok(char* restrict s1, const char* restrict s2);
+void* memset(void* s, int c, size_t n);
+char* strerror(int errnum);
+size_t strlen(const char* s);
+
+*/
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+#include_next <string.h>
+
+// MSVCRT, GNU libc and its derivates may already have the correct prototype in
+// <string.h>. This macro can be defined by users if their C library provides
+// the right signature.
+#if defined(__CORRECT_ISO_CPP_STRING_H_PROTO) || defined(_LIBCPP_MSVCRT) || \
+    defined(__sun__) || defined(_STRING_H_CPLUSPLUS_98_CONFORMANCE_)
+#define _LIBCPP_STRING_H_HAS_CONST_OVERLOADS
+#endif
+
+#if defined(__cplusplus) && !defined(_LIBCPP_STRING_H_HAS_CONST_OVERLOADS) && defined(_LIBCPP_PREFERRED_OVERLOAD)
+extern "C++" {
+inline _LIBCPP_INLINE_VISIBILITY
+char* __libcpp_strchr(const char* __s, int __c) {return (char*)strchr(__s, __c);}
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
+const char* strchr(const char* __s, int __c) {return __libcpp_strchr(__s, __c);}
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
+      char* strchr(      char* __s, int __c) {return __libcpp_strchr(__s, __c);}
+
+inline _LIBCPP_INLINE_VISIBILITY
+char* __libcpp_strpbrk(const char* __s1, const char* __s2) {return (char*)strpbrk(__s1, __s2);}
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
+const char* strpbrk(const char* __s1, const char* __s2) {return __libcpp_strpbrk(__s1, __s2);}
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
+      char* strpbrk(      char* __s1, const char* __s2) {return __libcpp_strpbrk(__s1, __s2);}
+
+inline _LIBCPP_INLINE_VISIBILITY
+char* __libcpp_strrchr(const char* __s, int __c) {return (char*)strrchr(__s, __c);}
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
+const char* strrchr(const char* __s, int __c) {return __libcpp_strrchr(__s, __c);}
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
+      char* strrchr(      char* __s, int __c) {return __libcpp_strrchr(__s, __c);}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void* __libcpp_memchr(const void* __s, int __c, size_t __n) {return (void*)memchr(__s, __c, __n);}
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
+const void* memchr(const void* __s, int __c, size_t __n) {return __libcpp_memchr(__s, __c, __n);}
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
+      void* memchr(      void* __s, int __c, size_t __n) {return __libcpp_memchr(__s, __c, __n);}
+
+inline _LIBCPP_INLINE_VISIBILITY
+char* __libcpp_strstr(const char* __s1, const char* __s2) {return (char*)strstr(__s1, __s2);}
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
+const char* strstr(const char* __s1, const char* __s2) {return __libcpp_strstr(__s1, __s2);}
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
+      char* strstr(      char* __s1, const char* __s2) {return __libcpp_strstr(__s1, __s2);}
+}
+#endif
+
+#endif  // _LIBCPP_STRING_H
diff --git a/include/support/android/locale_bionic.h b/include/support/android/locale_bionic.h
index 3a020da67e6b..1365563ee481 100644
--- a/include/support/android/locale_bionic.h
+++ b/include/support/android/locale_bionic.h
@@ -24,8 +24,8 @@ extern "C" {
 }
 #endif
 
-// Share implementation with Newlib
-#include <support/xlocale/xlocale.h>
+#include <support/xlocale/__posix_l_fallback.h>
+#include <support/xlocale/__strtonum_fallback.h>
 
 #endif // defined(__ANDROID__)
 #endif // _LIBCPP_SUPPORT_ANDROID_LOCALE_BIONIC_H
diff --git a/include/support/ibm/locale_mgmt_aix.h b/include/support/ibm/locale_mgmt_aix.h
new file mode 100644
index 000000000000..e3b7a78c45a0
--- /dev/null
+++ b/include/support/ibm/locale_mgmt_aix.h
@@ -0,0 +1,85 @@
+// -*- C++ -*-
+//===------------------- support/ibm/locale_mgmt_aix.h --------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_SUPPORT_IBM_LOCALE_MGMT_AIX_H
+#define _LIBCPP_SUPPORT_IBM_LOCALE_MGMT_AIX_H
+
+#if defined(_AIX)
+#include "cstdlib"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(_AIX71)
+// AIX 7.1 and higher has these definitions.  Definitions and stubs
+// are provied here as a temporary workaround on AIX 6.1.
+
+#define LC_COLLATE_MASK         1
+#define LC_CTYPE_MASK           2
+#define LC_MESSAGES_MASK        4
+#define LC_MONETARY_MASK        8
+#define LC_NUMERIC_MASK         16
+#define LC_TIME_MASK            32
+#define LC_ALL_MASK             (LC_COLLATE_MASK | LC_CTYPE_MASK | \
+                                 LC_MESSAGES_MASK | LC_MONETARY_MASK |\
+                                 LC_NUMERIC_MASK | LC_TIME_MASK)
+
+typedef void* locale_t;
+
+// The following are stubs.  They are not supported on AIX 6.1.
+static inline
+locale_t newlocale(int category_mask, const char *locale, locale_t base)
+{
+  _LC_locale_t *newloc, *loc;
+  if ((loc = (_LC_locale_t *)__xopen_locale(locale)) == NULL)
+  {
+    errno = EINVAL;
+    return (locale_t)0;
+  }
+  if ((newloc = (_LC_locale_t *)calloc(1, sizeof(_LC_locale_t))) == NULL)
+  {
+    errno = ENOMEM;
+    return (locale_t)0;
+  }
+  if (!base)
+    base = (_LC_locale_t *)__xopen_locale("C");
+  memcpy(newloc, base, sizeof (_LC_locale_t));
+  if (category_mask & LC_COLLATE_MASK)
+    newloc->lc_collate = loc->lc_collate;
+  if (category_mask & LC_CTYPE_MASK)
+    newloc->lc_ctype = loc->lc_ctype;
+  //if (category_mask & LC_MESSAGES_MASK)
+  //  newloc->lc_messages = loc->lc_messages;
+  if (category_mask & LC_MONETARY_MASK)
+    newloc->lc_monetary = loc->lc_monetary;
+  if (category_mask & LC_TIME_MASK)
+    newloc->lc_time = loc->lc_time;
+  if (category_mask & LC_NUMERIC_MASK)
+    newloc->lc_numeric = loc->lc_numeric;
+  return (locale_t)newloc;
+}
+static inline
+void freelocale(locale_t locobj)
+{
+  free(locobj);
+}
+static inline
+locale_t uselocale(locale_t newloc)
+{
+  return (locale_t)0;
+}
+#endif // !defined(_AIX71)
+
+#ifdef __cplusplus
+}
+#endif
+#endif // defined(_AIX)
+#endif // _LIBCPP_SUPPORT_IBM_LOCALE_MGMT_AIX_H
diff --git a/include/support/ibm/xlocale.h b/include/support/ibm/xlocale.h
index 8d99a5c7d34d..f39c0ba95d90 100644
--- a/include/support/ibm/xlocale.h
+++ b/include/support/ibm/xlocale.h
@@ -10,6 +10,7 @@
 
 #ifndef _LIBCPP_SUPPORT_IBM_XLOCALE_H
 #define _LIBCPP_SUPPORT_IBM_XLOCALE_H
+#include <support/ibm/locale_mgmt_aix.h>
 
 #if defined(_AIX)
 #include "cstdlib"
@@ -21,62 +22,6 @@ extern "C" {
 #if !defined(_AIX71)
 // AIX 7.1 and higher has these definitions.  Definitions and stubs
 // are provied here as a temporary workaround on AIX 6.1.
-
-#define LC_COLLATE_MASK         1
-#define LC_CTYPE_MASK           2
-#define LC_MESSAGES_MASK        4
-#define LC_MONETARY_MASK        8
-#define LC_NUMERIC_MASK         16
-#define LC_TIME_MASK            32
-#define LC_ALL_MASK             (LC_COLLATE_MASK | LC_CTYPE_MASK | \
-                                 LC_MESSAGES_MASK | LC_MONETARY_MASK |\
-                                 LC_NUMERIC_MASK | LC_TIME_MASK)
-
-typedef void* locale_t;
-
-// The following are stubs.  They are not supported on AIX 6.1.
-static inline
-locale_t newlocale(int category_mask, const char *locale, locale_t base)
-{
-  _LC_locale_t *newloc, *loc;
-  if ((loc = (_LC_locale_t *)__xopen_locale(locale)) == NULL)
-  {
-    errno = EINVAL;
-    return (locale_t)0;
-  }
-  if ((newloc = (_LC_locale_t *)calloc(1, sizeof(_LC_locale_t))) == NULL)
-  {
-    errno = ENOMEM;
-    return (locale_t)0;
-  }
-  if (!base)
-    base = (_LC_locale_t *)__xopen_locale("C");
-  memcpy(newloc, base, sizeof (_LC_locale_t));
-  if (category_mask & LC_COLLATE_MASK) 
-    newloc->lc_collate = loc->lc_collate;
-  if (category_mask & LC_CTYPE_MASK)
-    newloc->lc_ctype = loc->lc_ctype;
-  //if (category_mask & LC_MESSAGES_MASK)
-  //  newloc->lc_messages = loc->lc_messages;
-  if (category_mask & LC_MONETARY_MASK)
-    newloc->lc_monetary = loc->lc_monetary;
-  if (category_mask & LC_TIME_MASK)
-    newloc->lc_time = loc->lc_time;
-  if (category_mask & LC_NUMERIC_MASK)
-    newloc->lc_numeric = loc->lc_numeric;
-  return (locale_t)newloc; 
-}
-static inline
-void freelocale(locale_t locobj)
-{
-  free(locobj);
-}
-static inline
-locale_t uselocale(locale_t newloc)
-{
-  return (locale_t)0;
-}
-
 static inline
 int isalnum_l(int c, locale_t locale)
 {
diff --git a/include/support/newlib/xlocale.h b/include/support/newlib/xlocale.h
index d067cf85a3bc..4e4b23be8d6b 100644
--- a/include/support/newlib/xlocale.h
+++ b/include/support/newlib/xlocale.h
@@ -16,47 +16,9 @@
 #include <clocale>
 #include <cwctype>
 #include <ctype.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// Patch over newlib's lack of extended locale support
-typedef void *locale_t;
-static inline locale_t duplocale(locale_t) {
-  return NULL;
-}
-
-static inline void freelocale(locale_t) {
-}
-
-static inline locale_t newlocale(int, const char *, locale_t) {
-  return NULL;
-}
-
-static inline locale_t uselocale(locale_t) {
-  return NULL;
-}
-
-#define LC_COLLATE_MASK  (1 << LC_COLLATE)
-#define LC_CTYPE_MASK    (1 << LC_CTYPE)
-#define LC_MESSAGES_MASK (1 << LC_MESSAGES)
-#define LC_MONETARY_MASK (1 << LC_MONETARY)
-#define LC_NUMERIC_MASK  (1 << LC_NUMERIC)
-#define LC_TIME_MASK     (1 << LC_TIME)
-#define LC_ALL_MASK (LC_COLLATE_MASK|\
-                     LC_CTYPE_MASK|\
-                     LC_MONETARY_MASK|\
-                     LC_NUMERIC_MASK|\
-                     LC_TIME_MASK|\
-                     LC_MESSAGES_MASK)
-
-// Share implementation with Android's Bionic
-#include <support/xlocale/xlocale.h>
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
+#include <support/xlocale/__nop_locale_mgmt.h>
+#include <support/xlocale/__posix_l_fallback.h>
+#include <support/xlocale/__strtonum_fallback.h>
 
 #endif // _NEWLIB_VERSION
 
diff --git a/include/support/solaris/xlocale.h b/include/support/solaris/xlocale.h
index 62b0d74a6d23..e20ef7a6e53b 100644
--- a/include/support/solaris/xlocale.h
+++ b/include/support/solaris/xlocale.h
@@ -44,11 +44,6 @@ long strtol_l(const char *__nptr, char **__endptr,
   return strtol(__nptr, __endptr, __base);
 }
 static inline
-long double strtold_l(const char *__nptr, char **__endptr,
-    locale_t __loc) {
-  return strtold(__nptr, __endptr);
-}
-static inline
 unsigned long long strtoull_l(const char *__nptr, char **__endptr,
     int __base, locale_t __loc) {
   return strtoull(__nptr, __endptr, __base);
@@ -58,6 +53,21 @@ unsigned long strtoul_l(const char *__nptr, char **__endptr,
     int __base, locale_t __loc) {
   return strtoul(__nptr, __endptr, __base);
 }
+static inline
+float strtof_l(const char *__nptr, char **__endptr,
+    locale_t __loc) {
+  return strtof(__nptr, __endptr);
+}
+static inline
+double strtod_l(const char *__nptr, char **__endptr,
+    locale_t __loc) {
+  return strtod(__nptr, __endptr);
+}
+static inline
+long double strtold_l(const char *__nptr, char **__endptr,
+    locale_t __loc) {
+  return strtold(__nptr, __endptr);
+}
 
 
 #ifdef __cplusplus
diff --git a/include/support/win32/locale_mgmt_win32.h b/include/support/win32/locale_mgmt_win32.h
new file mode 100644
index 000000000000..b3316d62596f
--- /dev/null
+++ b/include/support/win32/locale_mgmt_win32.h
@@ -0,0 +1,33 @@
+// -*- C++ -*-
+//===----------------- support/win32/locale_mgmt_win32.h ------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_SUPPORT_WIN32_LOCALE_MGMT_WIN32_H
+#define _LIBCPP_SUPPORT_WIN32_LOCALE_MGMT_WIN32_H
+
+#include <xlocinfo.h> // _locale_t
+#define locale_t _locale_t
+#define LC_COLLATE_MASK _M_COLLATE
+#define LC_CTYPE_MASK _M_CTYPE
+#define LC_MONETARY_MASK _M_MONETARY
+#define LC_NUMERIC_MASK _M_NUMERIC
+#define LC_TIME_MASK _M_TIME
+#define LC_MESSAGES_MASK _M_MESSAGES
+#define LC_ALL_MASK (  LC_COLLATE_MASK \
+                     | LC_CTYPE_MASK \
+                     | LC_MESSAGES_MASK \
+                     | LC_MONETARY_MASK \
+                     | LC_NUMERIC_MASK \
+                     | LC_TIME_MASK )
+#define freelocale _free_locale
+// FIXME: base currently unused. Needs manual work to construct the new locale
+locale_t newlocale( int mask, const char * locale, locale_t base );
+locale_t uselocale( locale_t newloc );
+
+#endif // _LIBCPP_SUPPORT_WIN32_LOCALE_MGMT_WIN32_H
diff --git a/include/support/win32/locale_win32.h b/include/support/win32/locale_win32.h
index f728d234472f..7f3710ecc188 100644
--- a/include/support/win32/locale_win32.h
+++ b/include/support/win32/locale_win32.h
@@ -15,26 +15,10 @@
 extern "C" unsigned short  __declspec(dllimport) _ctype[];
 
 #include "support/win32/support.h"
+#include "support/win32/locale_mgmt_win32.h"
 #include <stdio.h>
 #include <memory>
-#include <xlocinfo.h> // _locale_t
-#define locale_t _locale_t
-#define LC_COLLATE_MASK _M_COLLATE
-#define LC_CTYPE_MASK _M_CTYPE
-#define LC_MONETARY_MASK _M_MONETARY
-#define LC_NUMERIC_MASK _M_NUMERIC
-#define LC_TIME_MASK _M_TIME
-#define LC_MESSAGES_MASK _M_MESSAGES
-#define LC_ALL_MASK (  LC_COLLATE_MASK \
-                     | LC_CTYPE_MASK \
-                     | LC_MESSAGES_MASK \
-                     | LC_MONETARY_MASK \
-                     | LC_NUMERIC_MASK \
-                     | LC_TIME_MASK )
-#define freelocale _free_locale
-// FIXME: base currently unused. Needs manual work to construct the new locale
-locale_t newlocale( int mask, const char * locale, locale_t base );
-locale_t uselocale( locale_t newloc );
+
 lconv *localeconv_l( locale_t loc );
 size_t mbrlen_l( const char *__restrict s, size_t n,
                  mbstate_t *__restrict ps, locale_t loc);
diff --git a/include/support/xlocale/__nop_locale_mgmt.h b/include/support/xlocale/__nop_locale_mgmt.h
new file mode 100644
index 000000000000..0d3f23a2c969
--- /dev/null
+++ b/include/support/xlocale/__nop_locale_mgmt.h
@@ -0,0 +1,52 @@
+// -*- C++ -*-
+//===------------  support/xlocale/__nop_locale_mgmt.h -----------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_SUPPORT_XLOCALE_NOP_LOCALE_MGMT_H
+#define _LIBCPP_SUPPORT_XLOCALE_NOP_LOCALE_MGMT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Patch over lack of extended locale support
+typedef void *locale_t;
+static inline locale_t duplocale(locale_t) {
+  return NULL;
+}
+
+static inline void freelocale(locale_t) {
+}
+
+static inline locale_t newlocale(int, const char *, locale_t) {
+  return NULL;
+}
+
+static inline locale_t uselocale(locale_t) {
+  return NULL;
+}
+
+#define LC_COLLATE_MASK  (1 << LC_COLLATE)
+#define LC_CTYPE_MASK    (1 << LC_CTYPE)
+#define LC_MESSAGES_MASK (1 << LC_MESSAGES)
+#define LC_MONETARY_MASK (1 << LC_MONETARY)
+#define LC_NUMERIC_MASK  (1 << LC_NUMERIC)
+#define LC_TIME_MASK     (1 << LC_TIME)
+#define LC_ALL_MASK (LC_COLLATE_MASK|\
+                     LC_CTYPE_MASK|\
+                     LC_MONETARY_MASK|\
+                     LC_NUMERIC_MASK|\
+                     LC_TIME_MASK|\
+                     LC_MESSAGES_MASK)
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif // _LIBCPP_SUPPORT_XLOCALE_NOP_LOCALE_MGMT_H
diff --git a/include/support/xlocale/__posix_l_fallback.h b/include/support/xlocale/__posix_l_fallback.h
new file mode 100644
index 000000000000..8bf9567ffc25
--- /dev/null
+++ b/include/support/xlocale/__posix_l_fallback.h
@@ -0,0 +1,165 @@
+// -*- C++ -*-
+//===--------------- support/xlocale/__posix_l_fallback.h -----------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+// These are reimplementations of some extended locale functions ( *_l ) that
+// are normally part of POSIX.  This shared implementation provides parts of the
+// extended locale support for libc's that normally don't have any (like
+// Android's bionic and Newlib).
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_SUPPORT_XLOCALE_POSIX_L_FALLBACK_H
+#define _LIBCPP_SUPPORT_XLOCALE_POSIX_L_FALLBACK_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+inline _LIBCPP_ALWAYS_INLINE int isalnum_l(int c, locale_t) {
+  return ::isalnum(c);
+}
+
+inline _LIBCPP_ALWAYS_INLINE int isalpha_l(int c, locale_t) {
+  return ::isalpha(c);
+}
+
+inline _LIBCPP_ALWAYS_INLINE int isblank_l(int c, locale_t) {
+  return ::isblank(c);
+}
+
+inline _LIBCPP_ALWAYS_INLINE int iscntrl_l(int c, locale_t) {
+  return ::iscntrl(c);
+}
+
+inline _LIBCPP_ALWAYS_INLINE int isdigit_l(int c, locale_t) {
+  return ::isdigit(c);
+}
+
+inline _LIBCPP_ALWAYS_INLINE int isgraph_l(int c, locale_t) {
+  return ::isgraph(c);
+}
+
+inline _LIBCPP_ALWAYS_INLINE int islower_l(int c, locale_t) {
+  return ::islower(c);
+}
+
+inline _LIBCPP_ALWAYS_INLINE int isprint_l(int c, locale_t) {
+  return ::isprint(c);
+}
+
+inline _LIBCPP_ALWAYS_INLINE int ispunct_l(int c, locale_t) {
+  return ::ispunct(c);
+}
+
+inline _LIBCPP_ALWAYS_INLINE int isspace_l(int c, locale_t) {
+  return ::isspace(c);
+}
+
+inline _LIBCPP_ALWAYS_INLINE int isupper_l(int c, locale_t) {
+  return ::isupper(c);
+}
+
+inline _LIBCPP_ALWAYS_INLINE int isxdigit_l(int c, locale_t) {
+  return ::isxdigit(c);
+}
+
+inline _LIBCPP_ALWAYS_INLINE int iswalnum_l(wint_t c, locale_t) {
+  return ::iswalnum(c);
+}
+
+inline _LIBCPP_ALWAYS_INLINE int iswalpha_l(wint_t c, locale_t) {
+  return ::iswalpha(c);
+}
+
+inline _LIBCPP_ALWAYS_INLINE int iswblank_l(wint_t c, locale_t) {
+  return ::iswblank(c);
+}
+
+inline _LIBCPP_ALWAYS_INLINE int iswcntrl_l(wint_t c, locale_t) {
+  return ::iswcntrl(c);
+}
+
+inline _LIBCPP_ALWAYS_INLINE int iswdigit_l(wint_t c, locale_t) {
+  return ::iswdigit(c);
+}
+
+inline _LIBCPP_ALWAYS_INLINE int iswgraph_l(wint_t c, locale_t) {
+  return ::iswgraph(c);
+}
+
+inline _LIBCPP_ALWAYS_INLINE int iswlower_l(wint_t c, locale_t) {
+  return ::iswlower(c);
+}
+
+inline _LIBCPP_ALWAYS_INLINE int iswprint_l(wint_t c, locale_t) {
+  return ::iswprint(c);
+}
+
+inline _LIBCPP_ALWAYS_INLINE int iswpunct_l(wint_t c, locale_t) {
+  return ::iswpunct(c);
+}
+
+inline _LIBCPP_ALWAYS_INLINE int iswspace_l(wint_t c, locale_t) {
+  return ::iswspace(c);
+}
+
+inline _LIBCPP_ALWAYS_INLINE int iswupper_l(wint_t c, locale_t) {
+  return ::iswupper(c);
+}
+
+inline _LIBCPP_ALWAYS_INLINE int iswxdigit_l(wint_t c, locale_t) {
+  return ::iswxdigit(c);
+}
+
+inline _LIBCPP_ALWAYS_INLINE int toupper_l(int c, locale_t) {
+  return ::toupper(c);
+}
+
+inline _LIBCPP_ALWAYS_INLINE int tolower_l(int c, locale_t) {
+  return ::tolower(c);
+}
+
+inline _LIBCPP_ALWAYS_INLINE int towupper_l(int c, locale_t) {
+  return ::towupper(c);
+}
+
+inline _LIBCPP_ALWAYS_INLINE int towlower_l(int c, locale_t) {
+  return ::towlower(c);
+}
+
+inline _LIBCPP_ALWAYS_INLINE int strcoll_l(const char *s1, const char *s2,
+                                           locale_t) {
+  return ::strcoll(s1, s2);
+}
+
+inline _LIBCPP_ALWAYS_INLINE size_t strxfrm_l(char *dest, const char *src,
+                                              size_t n, locale_t) {
+  return ::strxfrm(dest, src, n);
+}
+
+inline _LIBCPP_ALWAYS_INLINE size_t strftime_l(char *s, size_t max,
+                                               const char *format,
+                                               const struct tm *tm, locale_t) {
+  return ::strftime(s, max, format, tm);
+}
+
+inline _LIBCPP_ALWAYS_INLINE int wcscoll_l(const wchar_t *ws1,
+                                           const wchar_t *ws2, locale_t) {
+  return ::wcscoll(ws1, ws2);
+}
+
+inline _LIBCPP_ALWAYS_INLINE size_t wcsxfrm_l(wchar_t *dest, const wchar_t *src,
+                                              size_t n, locale_t) {
+  return ::wcsxfrm(dest, src, n);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _LIBCPP_SUPPORT_XLOCALE_POSIX_L_FALLBACK_H
diff --git a/include/support/xlocale/__strtonum_fallback.h b/include/support/xlocale/__strtonum_fallback.h
new file mode 100644
index 000000000000..4ae3918b3d30
--- /dev/null
+++ b/include/support/xlocale/__strtonum_fallback.h
@@ -0,0 +1,67 @@
+// -*- C++ -*-
+//===-------------- support/xlocale/__strtonum_fallback.h -----------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+// These are reimplementations of some extended locale functions ( *_l ) that
+// aren't part of POSIX.  They are widely available though (GLIBC, BSD, maybe
+// others).  The unifying aspect in this case is that all of these functions
+// convert strings to some numeric type.
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_SUPPORT_XLOCALE_STRTONUM_FALLBACK_H
+#define _LIBCPP_SUPPORT_XLOCALE_STRTONUM_FALLBACK_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+inline _LIBCPP_ALWAYS_INLINE float strtof_l(const char *nptr,
+                                            char **endptr, locale_t) {
+  return ::strtof(nptr, endptr);
+}
+
+inline _LIBCPP_ALWAYS_INLINE double strtod_l(const char *nptr,
+                                                   char **endptr, locale_t) {
+  return ::strtod(nptr, endptr);
+}
+
+inline _LIBCPP_ALWAYS_INLINE long double strtold_l(const char *nptr,
+                                                   char **endptr, locale_t) {
+  return ::strtold(nptr, endptr);
+}
+
+inline _LIBCPP_ALWAYS_INLINE long long
+strtoll_l(const char *nptr, char **endptr, int base, locale_t) {
+  return ::strtoll(nptr, endptr, base);
+}
+
+inline _LIBCPP_ALWAYS_INLINE unsigned long long
+strtoull_l(const char *nptr, char **endptr, int base, locale_t) {
+  return ::strtoull(nptr, endptr, base);
+}
+
+inline _LIBCPP_ALWAYS_INLINE long long
+wcstoll_l(const wchar_t *nptr, wchar_t **endptr, int base, locale_t) {
+  return ::wcstoll(nptr, endptr, base);
+}
+
+inline _LIBCPP_ALWAYS_INLINE unsigned long long
+wcstoull_l(const wchar_t *nptr, wchar_t **endptr, int base, locale_t) {
+  return ::wcstoull(nptr, endptr, base);
+}
+
+inline _LIBCPP_ALWAYS_INLINE long double wcstold_l(const wchar_t *nptr,
+                                                   wchar_t **endptr, locale_t) {
+  return ::wcstold(nptr, endptr);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _LIBCPP_SUPPORT_XLOCALE_STRTONUM_FALLBACK_H
diff --git a/include/support/xlocale/xlocale.h b/include/support/xlocale/xlocale.h
index 99f710e8f44e..e69de29bb2d1 100644
--- a/include/support/xlocale/xlocale.h
+++ b/include/support/xlocale/xlocale.h
@@ -1,194 +0,0 @@
-// -*- C++ -*-
-//===------------------- support/xlocale/xlocale.h ------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-// This is a shared implementation of a shim to provide extended locale support
-// on top of libc's that don't support it (like Android's bionic, and Newlib).
-//
-// The 'illusion' only works when the specified locale is "C" or "POSIX", but
-// that's about as good as we can do without implementing full xlocale support
-// in the underlying libc.
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_SUPPORT_XLOCALE_XLOCALE_H
-#define _LIBCPP_SUPPORT_XLOCALE_XLOCALE_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-static inline int isalnum_l(int c, locale_t) {
-  return isalnum(c);
-}
-
-static inline int isalpha_l(int c, locale_t) {
-  return isalpha(c);
-}
-
-static inline int isblank_l(int c, locale_t) {
-  return isblank(c);
-}
-
-static inline int iscntrl_l(int c, locale_t) {
-  return iscntrl(c);
-}
-
-static inline int isdigit_l(int c, locale_t) {
-  return isdigit(c);
-}
-
-static inline int isgraph_l(int c, locale_t) {
-  return isgraph(c);
-}
-
-static inline int islower_l(int c, locale_t) {
-  return islower(c);
-}
-
-static inline int isprint_l(int c, locale_t) {
-  return isprint(c);
-}
-
-static inline int ispunct_l(int c, locale_t) {
-  return ispunct(c);
-}
-
-static inline int isspace_l(int c, locale_t) {
-  return isspace(c);
-}
-
-static inline int isupper_l(int c, locale_t) {
-  return isupper(c);
-}
-
-static inline int isxdigit_l(int c, locale_t) {
-  return isxdigit(c);
-}
-
-static inline int iswalnum_l(wint_t c, locale_t) {
-  return iswalnum(c);
-}
-
-static inline int iswalpha_l(wint_t c, locale_t) {
-  return iswalpha(c);
-}
-
-static inline int iswblank_l(wint_t c, locale_t) {
-  return iswblank(c);
-}
-
-static inline int iswcntrl_l(wint_t c, locale_t) {
-  return iswcntrl(c);
-}
-
-static inline int iswdigit_l(wint_t c, locale_t) {
-  return iswdigit(c);
-}
-
-static inline int iswgraph_l(wint_t c, locale_t) {
-  return iswgraph(c);
-}
-
-static inline int iswlower_l(wint_t c, locale_t) {
-  return iswlower(c);
-}
-
-static inline int iswprint_l(wint_t c, locale_t) {
-  return iswprint(c);
-}
-
-static inline int iswpunct_l(wint_t c, locale_t) {
-  return iswpunct(c);
-}
-
-static inline int iswspace_l(wint_t c, locale_t) {
-  return iswspace(c);
-}
-
-static inline int iswupper_l(wint_t c, locale_t) {
-  return iswupper(c);
-}
-
-static inline int iswxdigit_l(wint_t c, locale_t) {
-  return iswxdigit(c);
-}
-
-static inline int toupper_l(int c, locale_t) {
-  return toupper(c);
-}
-
-static inline int tolower_l(int c, locale_t) {
-  return tolower(c);
-}
-
-static inline int towupper_l(int c, locale_t) {
-  return towupper(c);
-}
-
-static inline int towlower_l(int c, locale_t) {
-  return towlower(c);
-}
-
-static inline int strcoll_l(const char *s1, const char *s2, locale_t) {
-  return strcoll(s1, s2);
-}
-
-static inline size_t strxfrm_l(char *dest, const char *src, size_t n,
-                               locale_t) {
-  return strxfrm(dest, src, n);
-}
-
-static inline size_t strftime_l(char *s, size_t max, const char *format,
-                                const struct tm *tm, locale_t) {
-  return strftime(s, max, format, tm);
-}
-
-static inline int wcscoll_l(const wchar_t *ws1, const wchar_t *ws2, locale_t) {
-  return wcscoll(ws1, ws2);
-}
-
-static inline size_t wcsxfrm_l(wchar_t *dest, const wchar_t *src, size_t n,
-                               locale_t) {
-  return wcsxfrm(dest, src, n);
-}
-
-static inline long double strtold_l(const char *nptr, char **endptr, locale_t) {
-  return strtold(nptr, endptr);
-}
-
-static inline long long strtoll_l(const char *nptr, char **endptr, int base,
-                                  locale_t) {
-  return strtoll(nptr, endptr, base);
-}
-
-static inline unsigned long long strtoull_l(const char *nptr, char **endptr,
-                                            int base, locale_t) {
-  return strtoull(nptr, endptr, base);
-}
-
-static inline long long wcstoll_l(const wchar_t *nptr, wchar_t **endptr,
-                                  int base, locale_t) {
-  return wcstoll(nptr, endptr, base);
-}
-
-static inline unsigned long long wcstoull_l(const wchar_t *nptr,
-                                            wchar_t **endptr, int base,
-                                            locale_t) {
-  return wcstoull(nptr, endptr, base);
-}
-
-static inline long double wcstold_l(const wchar_t *nptr, wchar_t **endptr,
-                                    locale_t) {
-  return wcstold(nptr, endptr);
-}
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // _LIBCPP_SUPPORT_XLOCALE_XLOCALE_H
diff --git a/include/thread b/include/thread
index 6857e9edb68b..022021c5adde 100644
--- a/include/thread
+++ b/include/thread
@@ -98,8 +98,7 @@ void sleep_for(const chrono::duration<Rep, Period>& rel_time);
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 #include <tuple>
 #endif
-#include <pthread.h>
-#include <sched.h>
+#include <__threading_support>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
@@ -137,7 +136,7 @@ public:
 template <class _Tp>
 class __thread_specific_ptr
 {
-    pthread_key_t __key_;
+    __libcpp_tl_key __key_;
 
      // Only __thread_local_data() may construct a __thread_specific_ptr
      // and only with _Tp == __thread_struct.
@@ -155,7 +154,7 @@ public:
     ~__thread_specific_ptr();
 
     _LIBCPP_INLINE_VISIBILITY
-    pointer get() const {return static_cast<_Tp*>(pthread_getspecific(__key_));}
+    pointer get() const {return static_cast<_Tp*>(__libcpp_tl_get(__key_));}
     _LIBCPP_INLINE_VISIBILITY
     pointer operator*() const {return *get();}
     _LIBCPP_INLINE_VISIBILITY
@@ -174,12 +173,12 @@ __thread_specific_ptr<_Tp>::__at_thread_exit(void* __p)
 template <class _Tp>
 __thread_specific_ptr<_Tp>::__thread_specific_ptr()
 {
-    int __ec = pthread_key_create(&__key_, &__thread_specific_ptr::__at_thread_exit);
-#ifndef _LIBCPP_NO_EXCEPTIONS
+    int __ec = __libcpp_tl_create(
+        &__key_,
+        &__thread_specific_ptr::__at_thread_exit);
     if (__ec)
-        throw system_error(error_code(__ec, system_category()),
+        __throw_system_error(__ec,
                            "__thread_specific_ptr construction failed");
-#endif
 }
 
 template <class _Tp>
@@ -196,7 +195,7 @@ typename __thread_specific_ptr<_Tp>::pointer
 __thread_specific_ptr<_Tp>::release()
 {
     pointer __p = get();
-    pthread_setspecific(__key_, 0);
+    __libcpp_tl_set(__key_, nullptr);
     return __p;
 }
 
@@ -205,7 +204,7 @@ void
 __thread_specific_ptr<_Tp>::reset(pointer __p)
 {
     pointer __p_old = get();
-    pthread_setspecific(__key_, __p);
+    __libcpp_tl_set(__key_, __p);
     delete __p_old;
 }
 
@@ -219,14 +218,14 @@ _LIBCPP_INLINE_VISIBILITY __thread_id get_id() _NOEXCEPT;
 
 }  // this_thread
 
-template<> struct _LIBCPP_TYPE_VIS_ONLY hash<__thread_id>;
+template<> struct hash<__thread_id>;
 
 class _LIBCPP_TYPE_VIS_ONLY __thread_id
 {
     // FIXME: pthread_t is a pointer on Darwin but a long on Linux.
     // NULL is the no-thread value on Darwin.  Someone needs to check
     // on other platforms.  We assume 0 works everywhere for now.
-    pthread_t __id_;
+    __libcpp_thread_id __id_;
 
 public:
     _LIBCPP_INLINE_VISIBILITY
@@ -234,13 +233,13 @@ public:
 
     friend _LIBCPP_INLINE_VISIBILITY
         bool operator==(__thread_id __x, __thread_id __y) _NOEXCEPT
-        {return __x.__id_ == __y.__id_;}
+        {return __libcpp_thread_id_equal(__x.__id_, __y.__id_);}
     friend _LIBCPP_INLINE_VISIBILITY
         bool operator!=(__thread_id __x, __thread_id __y) _NOEXCEPT
         {return !(__x == __y);}
     friend _LIBCPP_INLINE_VISIBILITY
         bool operator< (__thread_id __x, __thread_id __y) _NOEXCEPT
-        {return __x.__id_ < __y.__id_;}
+        {return  __libcpp_thread_id_less(__x.__id_, __y.__id_);}
     friend _LIBCPP_INLINE_VISIBILITY
         bool operator<=(__thread_id __x, __thread_id __y) _NOEXCEPT
         {return !(__y < __x);}
@@ -260,7 +259,7 @@ public:
 
 private:
     _LIBCPP_INLINE_VISIBILITY
-    __thread_id(pthread_t __id) : __id_(__id) {}
+    __thread_id(__libcpp_thread_id __id) : __id_(__id) {}
 
     friend __thread_id this_thread::get_id() _NOEXCEPT;
     friend class _LIBCPP_TYPE_VIS thread;
@@ -274,7 +273,7 @@ struct _LIBCPP_TYPE_VIS_ONLY hash<__thread_id>
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(__thread_id __v) const
     {
-        return hash<pthread_t>()(__v.__id_);
+        return hash<__libcpp_thread_id>()(__v.__id_);
     }
 };
 
@@ -285,20 +284,20 @@ inline _LIBCPP_INLINE_VISIBILITY
 __thread_id
 get_id() _NOEXCEPT
 {
-    return pthread_self();
+    return __libcpp_thread_get_current_id();
 }
 
 }  // this_thread
 
 class _LIBCPP_TYPE_VIS thread
 {
-    pthread_t __t_;
+    __libcpp_thread_t __t_;
 
     thread(const thread&);
     thread& operator=(const thread&);
 public:
     typedef __thread_id id;
-    typedef pthread_t native_handle_type;
+    typedef __libcpp_thread_t native_handle_type;
 
     _LIBCPP_INLINE_VISIBILITY
     thread() _NOEXCEPT : __t_(0) {}
@@ -330,7 +329,7 @@ public:
     void join();
     void detach();
     _LIBCPP_INLINE_VISIBILITY
-    id get_id() const _NOEXCEPT {return __t_;}
+    id get_id() const _NOEXCEPT {return __libcpp_thread_get_id(&__t_);}
     _LIBCPP_INLINE_VISIBILITY
     native_handle_type native_handle() _NOEXCEPT {return __t_;}
 
@@ -339,21 +338,21 @@ public:
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 
-template <class _Fp, class ..._Args, size_t ..._Indices>
+template <class _TSp, class _Fp, class ..._Args, size_t ..._Indices>
 inline _LIBCPP_INLINE_VISIBILITY
 void
-__thread_execute(tuple<_Fp, _Args...>& __t, __tuple_indices<_Indices...>)
+__thread_execute(tuple<_TSp, _Fp, _Args...>& __t, __tuple_indices<_Indices...>)
 {
-    __invoke(_VSTD::move(_VSTD::get<0>(__t)), _VSTD::move(_VSTD::get<_Indices>(__t))...);
+    __invoke(_VSTD::move(_VSTD::get<1>(__t)), _VSTD::move(_VSTD::get<_Indices>(__t))...);
 }
 
 template <class _Fp>
-void*
-__thread_proxy(void* __vp)
+void* __thread_proxy(void* __vp)
 {
-    __thread_local_data().reset(new __thread_struct);
+    // _Fp = std::tuple< unique_ptr<__thread_struct>, Functor, Args...>
     std::unique_ptr<_Fp> __p(static_cast<_Fp*>(__vp));
-    typedef typename __make_tuple_indices<tuple_size<_Fp>::value, 1>::type _Index;
+    __thread_local_data().reset(_VSTD::get<0>(*__p).release());
+    typedef typename __make_tuple_indices<tuple_size<_Fp>::value, 2>::type _Index;
     __thread_execute(*__p, _Index());
     return nullptr;
 }
@@ -363,10 +362,14 @@ template <class _Fp, class ..._Args,
          >
 thread::thread(_Fp&& __f, _Args&&... __args)
 {
-    typedef tuple<typename decay<_Fp>::type, typename decay<_Args>::type...> _Gp;
-    _VSTD::unique_ptr<_Gp> __p(new _Gp(__decay_copy(_VSTD::forward<_Fp>(__f)),
-                                __decay_copy(_VSTD::forward<_Args>(__args))...));
-    int __ec = pthread_create(&__t_, 0, &__thread_proxy<_Gp>, __p.get());
+    typedef unique_ptr<__thread_struct> _TSPtr;
+    _TSPtr __tsp(new __thread_struct);
+    typedef tuple<_TSPtr, typename decay<_Fp>::type, typename decay<_Args>::type...> _Gp;
+    _VSTD::unique_ptr<_Gp> __p(
+            new _Gp(std::move(__tsp),
+                    __decay_copy(_VSTD::forward<_Fp>(__f)),
+                    __decay_copy(_VSTD::forward<_Args>(__args))...));
+    int __ec = __libcpp_thread_create(&__t_, &__thread_proxy<_Gp>, __p.get());
     if (__ec == 0)
         __p.release();
     else
@@ -376,22 +379,34 @@ thread::thread(_Fp&& __f, _Args&&... __args)
 #else  // _LIBCPP_HAS_NO_VARIADICS
 
 template <class _Fp>
-void*
-__thread_proxy(void* __vp)
+struct __thread_invoke_pair {
+    // This type is used to pass memory for thread local storage and a functor
+    // to a newly created thread because std::pair doesn't work with
+    // std::unique_ptr in C++03.
+    __thread_invoke_pair(_Fp& __f) : __tsp_(new __thread_struct), __fn_(__f) {}
+    unique_ptr<__thread_struct> __tsp_;
+    _Fp __fn_;
+};
+
+template <class _Fp>
+void* __thread_proxy_cxx03(void* __vp)
 {
-    __thread_local_data().reset(new __thread_struct);
     std::unique_ptr<_Fp> __p(static_cast<_Fp*>(__vp));
-    (*__p)();
+    __thread_local_data().reset(__p->__tsp_.release());
+    (__p->__fn_)();
     return nullptr;
 }
 
 template <class _Fp>
 thread::thread(_Fp __f)
 {
-    std::unique_ptr<_Fp> __p(new _Fp(__f));
-    int __ec = pthread_create(&__t_, 0, &__thread_proxy<_Fp>, __p.get());
+
+    typedef __thread_invoke_pair<_Fp> _InvokePair;
+    typedef std::unique_ptr<_InvokePair> _PairPtr;
+    _PairPtr __pp(new _InvokePair(__f));
+    int __ec = __libcpp_thread_create(&__t_, &__thread_proxy_cxx03<_InvokePair>, __pp.get());
     if (__ec == 0)
-        __p.release();
+        __pp.release();
     else
         __throw_system_error(__ec, "thread constructor failed");
 }
@@ -464,7 +479,7 @@ sleep_until(const chrono::time_point<chrono::steady_clock, _Duration>& __t)
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
-void yield() _NOEXCEPT {sched_yield();}
+void yield() _NOEXCEPT {__libcpp_thread_yield();}
 
 }  // this_thread
 
diff --git a/include/tuple b/include/tuple
index cb1e27d93cf2..6805d8c7635b 100644
--- a/include/tuple
+++ b/include/tuple
@@ -76,10 +76,18 @@ template <class... T> tuple<V...>  make_tuple(T&&...); // constexpr in C++14
 template <class... T> tuple<ATypes...> forward_as_tuple(T&&...) noexcept; // constexpr in C++14
 template <class... T> tuple<T&...> tie(T&...) noexcept; // constexpr in C++14
 template <class... Tuples> tuple<CTypes...> tuple_cat(Tuples&&... tpls); // constexpr in C++14
-  
+
+// [tuple.apply], calling a function with a tuple of arguments:
+template <class F, class Tuple>
+  constexpr decltype(auto) apply(F&& f, Tuple&& t); // C++17
+template <class T, class Tuple>
+  constexpr T make_from_tuple(Tuple&& t); // C++17
+
 // 20.4.1.4, tuple helper classes:
 template <class T> class tuple_size; // undefined
 template <class... T> class tuple_size<tuple<T...>>;
+template <class T>
+ constexpr size_t tuple_size_v = tuple_size<T>::value; // C++17
 template <size_t I, class T> class tuple_element; // undefined
 template <size_t I, class... T> class tuple_element<I, tuple<T...>>;
 template <size_t I, class T>
@@ -379,10 +387,8 @@ template <class ..._Tp>
 _LIBCPP_INLINE_VISIBILITY
 void __swallow(_Tp&&...) _NOEXCEPT {}
 
-template <bool ..._Pred>
-struct __all
-    : is_same<__all<_Pred...>, __all<(_Pred, true)...>>
-{ };
+template <class ..._Tp>
+struct __lazy_all : __all<_Tp::value...> {};
 
 template <class _Tp>
 struct __all_default_constructible;
@@ -446,7 +452,7 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
     template <class _Alloc, class _Tuple,
               class = typename enable_if
                       <
-                         __tuple_convertible<_Tuple, tuple<_Tp...> >::value
+                         __tuple_constructible<_Tuple, tuple<_Tp...> >::value
                       >::type
              >
         _LIBCPP_INLINE_VISIBILITY
@@ -499,6 +505,28 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
     }
 };
 
+template <bool _IsTuple, class _SizeTrait, size_t _Expected>
+struct __tuple_like_with_size_imp : false_type {};
+
+template <class _SizeTrait, size_t _Expected>
+struct __tuple_like_with_size_imp<true, _SizeTrait, _Expected>
+    : integral_constant<bool, _SizeTrait::value == _Expected> {};
+
+template <class _Tuple, size_t _ExpectedSize,
+          class _RawTuple = typename __uncvref<_Tuple>::type>
+using __tuple_like_with_size = __tuple_like_with_size_imp<
+                                   __tuple_like<_RawTuple>::value,
+                                   tuple_size<_RawTuple>, _ExpectedSize
+                              >;
+
+
+struct _LIBCPP_TYPE_VIS __check_tuple_constructor_fail {
+    template <class ...>
+    static constexpr bool __enable_explicit() { return false; }
+    template <class ...>
+    static constexpr bool __enable_implicit() { return false; }
+};
+
 template <class ..._Tp>
 class _LIBCPP_TYPE_VIS_ONLY tuple
 {
@@ -506,6 +534,118 @@ class _LIBCPP_TYPE_VIS_ONLY tuple
 
     base base_;
 
+    template <class ..._Args>
+    struct _PackExpandsToThisTuple : false_type {};
+
+    template <class _Arg>
+    struct _PackExpandsToThisTuple<_Arg>
+        : is_same<typename __uncvref<_Arg>::type, tuple> {};
+
+    template <bool _MaybeEnable, class _Dummy = void>
+    struct _CheckArgsConstructor : __check_tuple_constructor_fail {};
+
+    template <class _Dummy>
+    struct _CheckArgsConstructor<true, _Dummy>
+    {
+        template <class ..._Args>
+        static constexpr bool __enable_explicit() {
+            return
+                __tuple_constructible<
+                    tuple<_Args...>,
+                    typename __make_tuple_types<tuple,
+                             sizeof...(_Args) < sizeof...(_Tp) ?
+                                 sizeof...(_Args) :
+                                 sizeof...(_Tp)>::type
+                >::value &&
+                !__tuple_convertible<
+                    tuple<_Args...>,
+                    typename __make_tuple_types<tuple,
+                             sizeof...(_Args) < sizeof...(_Tp) ?
+                                 sizeof...(_Args) :
+                                 sizeof...(_Tp)>::type
+                >::value &&
+                __all_default_constructible<
+                    typename __make_tuple_types<tuple, sizeof...(_Tp),
+                             sizeof...(_Args) < sizeof...(_Tp) ?
+                                 sizeof...(_Args) :
+                                 sizeof...(_Tp)>::type
+                >::value;
+        }
+
+        template <class ..._Args>
+        static constexpr bool __enable_implicit() {
+            return
+                __tuple_convertible<
+                    tuple<_Args...>,
+                    typename __make_tuple_types<tuple,
+                             sizeof...(_Args) < sizeof...(_Tp) ?
+                                 sizeof...(_Args) :
+                                 sizeof...(_Tp)>::type
+                >::value &&
+                __all_default_constructible<
+                    typename __make_tuple_types<tuple, sizeof...(_Tp),
+                             sizeof...(_Args) < sizeof...(_Tp) ?
+                                 sizeof...(_Args) :
+                                 sizeof...(_Tp)>::type
+                >::value;
+        }
+    };
+
+    template <bool _MaybeEnable,
+              bool = sizeof...(_Tp) == 1,
+              class _Dummy = void>
+    struct _CheckTupleLikeConstructor : __check_tuple_constructor_fail {};
+
+    template <class _Dummy>
+    struct _CheckTupleLikeConstructor<true, false, _Dummy>
+    {
+        template <class _Tuple>
+        static constexpr bool __enable_implicit() {
+            return __tuple_convertible<_Tuple, tuple>::value;
+        }
+
+        template <class _Tuple>
+        static constexpr bool __enable_explicit() {
+            return __tuple_constructible<_Tuple, tuple>::value
+               && !__tuple_convertible<_Tuple, tuple>::value;
+        }
+    };
+
+    template <class _Dummy>
+    struct _CheckTupleLikeConstructor<true, true, _Dummy>
+    {
+        // This trait is used to disable the tuple-like constructor when
+        // the UTypes... constructor should be selected instead.
+        // See LWG issue #2549.
+        template <class _Tuple>
+        using _PreferTupleLikeConstructor = __lazy_or<
+            // Don't attempt the two checks below if the tuple we are given
+            // has the same type as this tuple.
+            is_same<typename __uncvref<_Tuple>::type, tuple>,
+            __lazy_and<
+                __lazy_not<is_constructible<_Tp..., _Tuple>>,
+                __lazy_not<is_convertible<_Tuple, _Tp...>>
+            >
+        >;
+
+        template <class _Tuple>
+        static constexpr bool __enable_implicit() {
+            return __lazy_and<
+                __tuple_convertible<_Tuple, tuple>,
+                _PreferTupleLikeConstructor<_Tuple>
+            >::value;
+        }
+
+        template <class _Tuple>
+        static constexpr bool __enable_explicit() {
+            return __lazy_and<
+                __tuple_constructible<_Tuple, tuple>,
+                _PreferTupleLikeConstructor<_Tuple>,
+                __lazy_not<__tuple_convertible<_Tuple, tuple>>
+            >::value;
+        }
+    };
+
     template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11
         typename tuple_element<_Jp, tuple<_Up...> >::type& get(tuple<_Up...>&) _NOEXCEPT;
     template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11
@@ -523,8 +663,30 @@ public:
     _LIBCPP_CONSTEXPR tuple()
         _NOEXCEPT_(__all<is_nothrow_default_constructible<_Tp>::value...>::value) {}
 
+    template <class _AllocArgT, class _Alloc, bool _Dummy = true, class = typename enable_if<
+        __lazy_and<
+            is_same<allocator_arg_t, _AllocArgT>,
+            __lazy_all<__dependent_type<is_default_constructible<_Tp>, _Dummy>...>
+       >::value
+    >::type>
+    _LIBCPP_INLINE_VISIBILITY
+    tuple(_AllocArgT, _Alloc const& __a)
+      : base_(allocator_arg_t(), __a,
+                    __tuple_indices<>(), __tuple_types<>(),
+                    typename __make_tuple_indices<sizeof...(_Tp), 0>::type(),
+                    __tuple_types<_Tp...>()) {}
+
+    template <bool _Dummy = true,
+              typename enable_if
+                      <
+                         _CheckArgsConstructor<
+                            _Dummy
+                         >::template __enable_implicit<_Tp...>(),
+                         bool
+                      >::type = false
+        >
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
-    explicit tuple(const _Tp& ... __t) _NOEXCEPT_((__all<is_nothrow_copy_constructible<_Tp>::value...>::value)) 
+    tuple(const _Tp& ... __t) _NOEXCEPT_((__all<is_nothrow_copy_constructible<_Tp>::value...>::value))
         : base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
                 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
                 typename __make_tuple_indices<0>::type(),
@@ -532,8 +694,54 @@ public:
                 __t...
                ) {}
 
-    template <class _Alloc>
+    template <bool _Dummy = true,
+              typename enable_if
+                      <
+                         _CheckArgsConstructor<
+                            _Dummy
+                         >::template __enable_explicit<_Tp...>(),
+                         bool
+                      >::type = false
+        >
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+    explicit tuple(const _Tp& ... __t) _NOEXCEPT_((__all<is_nothrow_copy_constructible<_Tp>::value...>::value))
+        : base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
+                typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
+                typename __make_tuple_indices<0>::type(),
+                typename __make_tuple_types<tuple, 0>::type(),
+                __t...
+               ) {}
+
+    template <class _Alloc, bool _Dummy = true,
+              typename enable_if
+                      <
+                         _CheckArgsConstructor<
+                            _Dummy
+                         >::template __enable_implicit<_Tp...>(),
+                         bool
+                      >::type = false
+        >
+      _LIBCPP_INLINE_VISIBILITY
+      tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
+        : base_(allocator_arg_t(), __a,
+                typename __make_tuple_indices<sizeof...(_Tp)>::type(),
+                typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
+                typename __make_tuple_indices<0>::type(),
+                typename __make_tuple_types<tuple, 0>::type(),
+                __t...
+               ) {}
+
+    template <class _Alloc, bool _Dummy = true,
+              typename enable_if
+                      <
+                         _CheckArgsConstructor<
+                            _Dummy
+                         >::template __enable_explicit<_Tp...>(),
+                         bool
+                      >::type = false
+        >
       _LIBCPP_INLINE_VISIBILITY
+      explicit
       tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
         : base_(allocator_arg_t(), __a,
                 typename __make_tuple_indices<sizeof...(_Tp)>::type(),
@@ -546,21 +754,10 @@ public:
     template <class ..._Up,
               typename enable_if
                       <
-                         sizeof...(_Up) <= sizeof...(_Tp) &&
-                         __tuple_convertible
-                         <
-                            tuple<_Up...>,
-                            typename __make_tuple_types<tuple,
-                                     sizeof...(_Up) < sizeof...(_Tp) ?
-                                        sizeof...(_Up) :
-                                        sizeof...(_Tp)>::type
-                         >::value &&
-                         __all_default_constructible<
-                            typename __make_tuple_types<tuple, sizeof...(_Tp),
-                                sizeof...(_Up) < sizeof...(_Tp) ?
-                                    sizeof...(_Up) :
-                                    sizeof...(_Tp)>::type
-                         >::value,
+                         _CheckArgsConstructor<
+                             sizeof...(_Up) <= sizeof...(_Tp)
+                             && !_PackExpandsToThisTuple<_Up...>::value
+                         >::template __enable_implicit<_Up...>(),
                          bool
                       >::type = false
              >
@@ -584,31 +781,12 @@ public:
     template <class ..._Up,
               typename enable_if
                       <
-                         sizeof...(_Up) <= sizeof...(_Tp) &&
-                         __tuple_constructible
-                         <
-                            tuple<_Up...>,
-                            typename __make_tuple_types<tuple,
-                                     sizeof...(_Up) < sizeof...(_Tp) ?
-                                        sizeof...(_Up) :
-                                        sizeof...(_Tp)>::type
-                         >::value &&
-                         !__tuple_convertible
-                         <
-                            tuple<_Up...>,
-                            typename __make_tuple_types<tuple,
-                                     sizeof...(_Up) < sizeof...(_Tp) ?
-                                        sizeof...(_Up) :
-                                        sizeof...(_Tp)>::type
-                         >::value &&
-                         __all_default_constructible<
-                            typename __make_tuple_types<tuple, sizeof...(_Tp),
-                                sizeof...(_Up) < sizeof...(_Tp) ?
-                                    sizeof...(_Up) :
-                                    sizeof...(_Tp)>::type
-                         >::value,
+                         _CheckArgsConstructor<
+                             sizeof...(_Up) <= sizeof...(_Tp)
+                             && !_PackExpandsToThisTuple<_Up...>::value
+                         >::template __enable_explicit<_Up...>(),
                          bool
-                      >::type =false
+                      >::type = false
              >
         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
         explicit
@@ -629,26 +807,36 @@ public:
                     _VSTD::forward<_Up>(__u)...) {}
 
     template <class _Alloc, class ..._Up,
-              class = typename enable_if
+              typename enable_if
                       <
-                         sizeof...(_Up) <= sizeof...(_Tp) &&
-                         __tuple_convertible
-                         <
-                            tuple<_Up...>,
-                            typename __make_tuple_types<tuple,
-                                     sizeof...(_Up) < sizeof...(_Tp) ?
-                                        sizeof...(_Up) :
-                                        sizeof...(_Tp)>::type
-                         >::value &&
-                         __all_default_constructible<
-                            typename __make_tuple_types<tuple, sizeof...(_Tp),
-                                sizeof...(_Up) < sizeof...(_Tp) ?
-                                    sizeof...(_Up) :
-                                    sizeof...(_Tp)>::type
-                         >::value
-                      >::type
+                         _CheckArgsConstructor<
+                             sizeof...(_Up) == sizeof...(_Tp) &&
+                             !_PackExpandsToThisTuple<_Up...>::value
+                         >::template __enable_implicit<_Up...>(),
+                         bool
+                      >::type = false
+             >
+        _LIBCPP_INLINE_VISIBILITY
+        tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
+            : base_(allocator_arg_t(), __a,
+                    typename __make_tuple_indices<sizeof...(_Up)>::type(),
+                    typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
+                    typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
+                    typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
+                    _VSTD::forward<_Up>(__u)...) {}
+
+    template <class _Alloc, class ..._Up,
+              typename enable_if
+                      <
+                         _CheckArgsConstructor<
+                             sizeof...(_Up) == sizeof...(_Tp) &&
+                             !_PackExpandsToThisTuple<_Up...>::value
+                         >::template __enable_explicit<_Up...>(),
+                         bool
+                      >::type = false
              >
         _LIBCPP_INLINE_VISIBILITY
+        explicit
         tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
             : base_(allocator_arg_t(), __a,
                     typename __make_tuple_indices<sizeof...(_Up)>::type(),
@@ -660,7 +848,10 @@ public:
     template <class _Tuple,
               typename enable_if
                       <
-                         __tuple_convertible<_Tuple, tuple>::value,
+                         _CheckTupleLikeConstructor<
+                             __tuple_like_with_size<_Tuple, sizeof...(_Tp)>::value
+                             && !_PackExpandsToThisTuple<_Tuple>::value
+                         >::template __enable_implicit<_Tuple>(),
                          bool
                       >::type = false
              >
@@ -671,8 +862,10 @@ public:
     template <class _Tuple,
               typename enable_if
                       <
-                         __tuple_constructible<_Tuple, tuple>::value &&
-                         !__tuple_convertible<_Tuple, tuple>::value,
+                         _CheckTupleLikeConstructor<
+                             __tuple_like_with_size<_Tuple, sizeof...(_Tp)>::value
+                             && !_PackExpandsToThisTuple<_Tuple>::value
+                         >::template __enable_explicit<_Tuple>(),
                          bool
                       >::type = false
              >
@@ -682,12 +875,29 @@ public:
             : base_(_VSTD::forward<_Tuple>(__t)) {}
 
     template <class _Alloc, class _Tuple,
-              class = typename enable_if
+              typename enable_if
                       <
-                         __tuple_convertible<_Tuple, tuple>::value
-                      >::type
+                         _CheckTupleLikeConstructor<
+                             __tuple_like_with_size<_Tuple, sizeof...(_Tp)>::value
+                         >::template __enable_implicit<_Tuple>(),
+                         bool
+                      >::type = false
+             >
+        _LIBCPP_INLINE_VISIBILITY
+        tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
+            : base_(allocator_arg_t(), __a, _VSTD::forward<_Tuple>(__t)) {}
+
+    template <class _Alloc, class _Tuple,
+              typename enable_if
+                      <
+                         _CheckTupleLikeConstructor<
+                             __tuple_like_with_size<_Tuple, sizeof...(_Tp)>::value
+                         >::template __enable_explicit<_Tuple>(),
+                         bool
+                      >::type = false
              >
         _LIBCPP_INLINE_VISIBILITY
+        explicit
         tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
             : base_(allocator_arg_t(), __a, _VSTD::forward<_Tuple>(__t)) {}
 
@@ -784,39 +994,44 @@ get(const tuple<_Tp...>&& __t) _NOEXCEPT
 }
 
 #if _LIBCPP_STD_VER > 11
-// get by type
-template <typename _T1, size_t _Idx, typename... _Args>
-struct __find_exactly_one_t_helper;
-
-// -- find exactly one
-template <typename _T1, size_t _Idx, typename... _Args>
-struct __find_exactly_one_t_checker {
-    static constexpr size_t value = _Idx;
-//  Check the rest of the list to make sure there's only one
-    static_assert ( __find_exactly_one_t_helper<_T1, 0, _Args...>::value == -1, "type can only occur once in type list" );
-    };
 
+namespace __find_detail {
 
-template <typename _T1, size_t _Idx>
-struct __find_exactly_one_t_helper <_T1, _Idx> {
-    static constexpr size_t value = -1;
-    };
+static constexpr size_t __not_found = -1;
+static constexpr size_t __ambiguous = __not_found - 1;
 
-template <typename _T1, size_t _Idx, typename _Head, typename... _Args>
-struct __find_exactly_one_t_helper <_T1, _Idx, _Head, _Args...> {
-    static constexpr size_t value =
-        std::conditional<
-            std::is_same<_T1, _Head>::value,
-            __find_exactly_one_t_checker<_T1, _Idx,   _Args...>,
-            __find_exactly_one_t_helper <_T1, _Idx+1, _Args...>
-        >::type::value;
-    };
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr size_t __find_idx_return(size_t __curr_i, size_t __res, bool __matches) {
+    return !__matches ? __res :
+        (__res == __not_found ? __curr_i : __ambiguous);
+}
+
+template <size_t _Nx>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr size_t __find_idx(size_t __i, const bool (&__matches)[_Nx]) {
+  return __i == _Nx ? __not_found :
+      __find_idx_return(__i, __find_idx(__i + 1, __matches), __matches[__i]);
+}
+
+template <class _T1, class ..._Args>
+struct __find_exactly_one_checked {
+  static constexpr bool __matches[] = {is_same<_T1, _Args>::value...};
+    static constexpr size_t value = __find_detail::__find_idx(0, __matches);
+    static_assert (value != __not_found, "type not found in type list" );
+    static_assert(value != __ambiguous,"type occurs more than once in type list");
+};
+
+template <class _T1>
+struct __find_exactly_one_checked<_T1> {
+    static_assert(!is_same<_T1, _T1>::value, "type not in empty type list");
+};
+
+} // namespace __find_detail;
 
 template <typename _T1, typename... _Args>
-struct __find_exactly_one_t {
-    static constexpr size_t value = __find_exactly_one_t_helper<_T1, 0, _Args...>::value;
-    static_assert ( value != -1, "type not found in type list" );
-    };
+struct __find_exactly_one_t
+    : public __find_detail::__find_exactly_one_checked<_T1, _Args...> {
+};
 
 template <class _T1, class... _Args>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1154,6 +1369,50 @@ pair<_T1, _T2>::pair(piecewise_construct_t,
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
+#if _LIBCPP_STD_VER > 14
+template <class _Tp>
+constexpr size_t tuple_size_v = tuple_size<_Tp>::value;
+
+#define _LIBCPP_NOEXCEPT_RETURN(...) noexcept(noexcept(__VA_ARGS__)) { return __VA_ARGS__; }
+
+template <class _Fn, class _Tuple, size_t ..._Id>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr decltype(auto) __apply_tuple_impl(_Fn && __f, _Tuple && __t,
+                                            __tuple_indices<_Id...>)
+_LIBCPP_NOEXCEPT_RETURN(
+    _VSTD::__invoke_constexpr(
+        _VSTD::forward<_Fn>(__f),
+        _VSTD::get<_Id>(_VSTD::forward<_Tuple>(__t))...)
+)
+
+template <class _Fn, class _Tuple>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr decltype(auto) apply(_Fn && __f, _Tuple && __t)
+_LIBCPP_NOEXCEPT_RETURN(
+    _VSTD::__apply_tuple_impl(
+        _VSTD::forward<_Fn>(__f), _VSTD::forward<_Tuple>(__t),
+        typename __make_tuple_indices<tuple_size_v<decay_t<_Tuple>>>::type{})
+)
+
+template <class _Tp, class _Tuple, size_t... _Idx>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr _Tp __make_from_tuple_impl(_Tuple&& __t, __tuple_indices<_Idx...>)
+_LIBCPP_NOEXCEPT_RETURN(
+    _Tp(_VSTD::get<_Idx>(_VSTD::forward<_Tuple>(__t))...)
+)
+
+template <class _Tp, class _Tuple>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr _Tp make_from_tuple(_Tuple&& __t)
+_LIBCPP_NOEXCEPT_RETURN(
+    _VSTD::__make_from_tuple_impl<_Tp>(_VSTD::forward<_Tuple>(__t),
+        typename __make_tuple_indices<tuple_size_v<decay_t<_Tuple>>>::type{})
+)
+
+#undef _LIBCPP_NOEXCEPT_RETURN
+
+#endif // _LIBCPP_STD_VER > 14
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_TUPLE
diff --git a/include/type_traits b/include/type_traits
index b7adfebceeb9..821a73c764dd 100644
--- a/include/type_traits
+++ b/include/type_traits
@@ -105,6 +105,8 @@ namespace std
     template <class T, class U>       struct is_assignable;
     template <class T>                struct is_copy_assignable;
     template <class T>                struct is_move_assignable;
+    template <class T, class U>       struct is_swappable_with;       // C++17
+    template <class T>                struct is_swappable;            // C++17
     template <class T>                struct is_destructible;
 
     template <class T, class... Args> struct is_trivially_constructible;
@@ -123,6 +125,8 @@ namespace std
     template <class T, class U>       struct is_nothrow_assignable;
     template <class T>                struct is_nothrow_copy_assignable;
     template <class T>                struct is_nothrow_move_assignable;
+    template <class T, class U>       struct is_nothrow_swappable_with; // C++17
+    template <class T>                struct is_nothrow_swappable;      // C++17
     template <class T>                struct is_nothrow_destructible;
 
     template <class T> struct has_virtual_destructor;
@@ -132,6 +136,14 @@ namespace std
     template <class Base, class Derived> struct is_base_of;
     template <class From, class To> struct is_convertible;
 
+    template <class, class R = void> struct is_callable; // not defined
+    template <class Fn, class... ArgTypes, class R>
+      struct is_callable<Fn(ArgTypes...), R>;
+
+    template <class, class R = void> struct is_nothrow_callable; // not defined
+    template <class Fn, class... ArgTypes, class R>
+      struct is_nothrow_callable<Fn(ArgTypes...), R>;
+
     // Alignment properties and transformations:
     template <class T> struct alignment_of;
     template <size_t Len, size_t Align = most_stringent_alignment_requirement>
@@ -292,6 +304,10 @@ namespace std
         = is_copy_assignable<T>::value;                                  // C++17
       template <class T> constexpr bool is_move_assignable_v
         = is_move_assignable<T>::value;                                  // C++17
+      template <class T, class U> constexpr bool is_swappable_with_v
+        = is_swappable_with<T, U>::value;                                // C++17
+      template <class T> constexpr bool is_swappable_v
+        = is_swappable<T>::value;                                        // C++17
       template <class T> constexpr bool is_destructible_v
         = is_destructible<T>::value;                                     // C++17
       template <class T, class... Args> constexpr bool is_trivially_constructible_v
@@ -324,6 +340,10 @@ namespace std
         = is_nothrow_copy_assignable<T>::value;                          // C++17
       template <class T> constexpr bool is_nothrow_move_assignable_v
         = is_nothrow_move_assignable<T>::value;                          // C++17
+      template <class T, class U> constexpr bool is_nothrow_swappable_with_v
+        = is_nothrow_swappable_with<T, U>::value;                       // C++17
+      template <class T> constexpr bool is_nothrow_swappable_v
+        = is_nothrow_swappable<T>::value;                               // C++17
       template <class T> constexpr bool is_nothrow_destructible_v
         = is_nothrow_destructible<T>::value;                             // C++17
       template <class T> constexpr bool has_virtual_destructor_v
@@ -344,6 +364,10 @@ namespace std
         = is_base_of<Base, Derived>::value;                              // C++17
       template <class From, class To> constexpr bool is_convertible_v
         = is_convertible<From, To>::value;                               // C++17
+      template <class T, class R = void> constexpr bool is_callable_v
+        = is_callable<T, R>::value;                                      // C++17
+      template <class T, class R = void> constexpr bool is_nothrow_callable_v
+        = is_nothrow_callable<T, R>::value;                              // C++17
 
       // [meta.logical], logical operator traits:
       template<class... B> struct conjunction;                           // C++17
@@ -368,6 +392,10 @@ namespace std
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+template <class _T1, class _T2> struct _LIBCPP_TYPE_VIS_ONLY pair;
+template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY reference_wrapper;
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY hash;
+
 template <class>
 struct __void_t { typedef void type; };
 
@@ -397,15 +425,29 @@ template <bool _Bp, class _Tp = void> using enable_if_t = typename enable_if<_Bp
 #endif
 
 // addressof
+#if __has_builtin(__builtin_addressof)
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_CONSTEXPR_AFTER_CXX14
+_LIBCPP_NO_CFI _LIBCPP_INLINE_VISIBILITY
+_Tp*
+addressof(_Tp& __x) _NOEXCEPT
+{
+    return __builtin_addressof(__x);
+}
+
+#else
+
+template <class _Tp>
+inline _LIBCPP_NO_CFI _LIBCPP_INLINE_VISIBILITY
 _Tp*
 addressof(_Tp& __x) _NOEXCEPT
 {
     return (_Tp*)&reinterpret_cast<const volatile char&>(__x);
 }
 
+#endif // __has_builtin(__builtin_addressof)
+
 #if defined(_LIBCPP_HAS_OBJC_ARC) && !defined(_LIBCPP_PREDEFINED_OBJC_ARC_ADDRESSOF)
 // Objective-C++ Automatic Reference Counting uses qualified pointers
 // that require special addressof() signatures. When
@@ -957,6 +999,19 @@ template <class _Tp> _LIBCPP_CONSTEXPR bool is_compound_v
     = is_compound<_Tp>::value;
 #endif
 
+
+// __is_referenceable  [defns.referenceable]
+
+struct __is_referenceable_impl {
+    template <class _Tp> static _Tp& __test(int);
+    template <class _Tp> static __two __test(...);
+};
+
+template <class _Tp>
+struct __is_referenceable : integral_constant<bool,
+    !is_same<decltype(__is_referenceable_impl::__test<_Tp>(0)), __two>::value> {};
+
+
 // add_const
 
 template <class _Tp, bool = is_reference<_Tp>::value ||
@@ -1014,12 +1069,11 @@ template <class _Tp> using remove_reference_t = typename remove_reference<_Tp>::
 
 // add_lvalue_reference
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY add_lvalue_reference                      {typedef _Tp& type;};
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY add_lvalue_reference<_Tp&>                {typedef _Tp& type;};  // for older compiler
-template <>          struct _LIBCPP_TYPE_VIS_ONLY add_lvalue_reference<void>                {typedef void type;};
-template <>          struct _LIBCPP_TYPE_VIS_ONLY add_lvalue_reference<const void>          {typedef const void type;};
-template <>          struct _LIBCPP_TYPE_VIS_ONLY add_lvalue_reference<volatile void>       {typedef volatile void type;};
-template <>          struct _LIBCPP_TYPE_VIS_ONLY add_lvalue_reference<const volatile void> {typedef const volatile void type;};
+template <class _Tp, bool = __is_referenceable<_Tp>::value> struct __add_lvalue_reference_impl            { typedef _Tp  type; };
+template <class _Tp                                       > struct __add_lvalue_reference_impl<_Tp, true> { typedef _Tp& type; };
+
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY add_lvalue_reference
+{typedef typename __add_lvalue_reference_impl<_Tp>::type type;};
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type;
@@ -1027,11 +1081,11 @@ template <class _Tp> using add_lvalue_reference_t = typename add_lvalue_referenc
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY  add_rvalue_reference                     {typedef _Tp&& type;};
-template <>          struct _LIBCPP_TYPE_VIS_ONLY add_rvalue_reference<void>                {typedef void type;};
-template <>          struct _LIBCPP_TYPE_VIS_ONLY add_rvalue_reference<const void>          {typedef const void type;};
-template <>          struct _LIBCPP_TYPE_VIS_ONLY add_rvalue_reference<volatile void>       {typedef volatile void type;};
-template <>          struct _LIBCPP_TYPE_VIS_ONLY add_rvalue_reference<const volatile void> {typedef const volatile void type;};
+template <class _Tp, bool = __is_referenceable<_Tp>::value> struct __add_rvalue_reference_impl            { typedef _Tp   type; };
+template <class _Tp                                       > struct __add_rvalue_reference_impl<_Tp, true> { typedef _Tp&& type; };
+
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY add_rvalue_reference
+{typedef typename __add_rvalue_reference_impl<_Tp>::type type;};
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type;
@@ -1041,8 +1095,11 @@ template <class _Tp> using add_rvalue_reference_t = typename add_rvalue_referenc
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
+template <class _Tp> _Tp&& __declval(int);
+template <class _Tp> _Tp   __declval(long);
+
 template <class _Tp>
-typename add_rvalue_reference<_Tp>::type
+decltype(_VSTD::__declval<_Tp>(0))
 declval() _NOEXCEPT;
 
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -1053,6 +1110,24 @@ declval();
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
+// __uncvref
+
+template <class _Tp>
+struct __uncvref  {
+    typedef typename remove_cv<typename remove_reference<_Tp>::type>::type type;
+};
+
+template <class _Tp>
+struct __unconstref {
+    typedef typename remove_const<typename remove_reference<_Tp>::type>::type type;
+};
+
+// __is_same_uncvref
+
+template <class _Tp, class _Up>
+struct __is_same_uncvref : is_same<typename __uncvref<_Tp>::type,
+                                   typename __uncvref<_Up>::type> {};
+
 struct __any
 {
     __any(...);
@@ -1072,8 +1147,16 @@ template <class _Tp> using remove_pointer_t = typename remove_pointer<_Tp>::type
 
 // add_pointer
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY add_pointer
+template <class _Tp, 
+        bool = __is_referenceable<_Tp>::value || 
+                is_same<typename remove_cv<_Tp>::type, void>::value>
+struct __add_pointer_impl
     {typedef typename remove_reference<_Tp>::type* type;};
+template <class _Tp> struct __add_pointer_impl<_Tp, false> 
+    {typedef _Tp type;};
+
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY add_pointer
+    {typedef typename __add_pointer_impl<_Tp>::type type;};
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using add_pointer_t = typename add_pointer<_Tp>::type;
@@ -1301,16 +1384,9 @@ struct __is_convertible_test : public false_type {};
 
 template <class _From, class _To>
 struct __is_convertible_test<_From, _To,
-    decltype(__test_convert<_To>(_VSTD::declval<_From>()))> : public true_type
+    decltype(_VSTD::__is_convertible_imp::__test_convert<_To>(_VSTD::declval<_From>()))> : public true_type
 {};
 
-template <class _Tp> __two __test(...);
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-template <class _Tp> _Tp&& __source();
-#else
-template <class _Tp> typename remove_reference<_Tp>::type& __source();
-#endif
-
 template <class _Tp, bool _IsArray =    is_array<_Tp>::value,
                      bool _IsFunction = is_function<_Tp>::value,
                      bool _IsVoid =     is_void<_Tp>::value>
@@ -1350,41 +1426,6 @@ struct __is_convertible
     >
 {};
 
-template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 1, 0> : false_type {};
-
-template <class _T1> struct __is_convertible<_T1, const _T1&, 1, 0> : true_type {};
-template <class _T1> struct __is_convertible<const _T1, const _T1&, 1, 0> : true_type {};
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-template <class _T1> struct __is_convertible<_T1, _T1&&, 1, 0> : true_type {};
-template <class _T1> struct __is_convertible<_T1, const _T1&&, 1, 0> : true_type {};
-template <class _T1> struct __is_convertible<_T1, volatile _T1&&, 1, 0> : true_type {};
-template <class _T1> struct __is_convertible<_T1, const volatile _T1&&, 1, 0> : true_type {};
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
-template <class _T1, class _T2> struct __is_convertible<_T1, _T2*, 1, 0>
-    : public integral_constant<bool, __is_convertible<typename remove_all_extents<_T1>::type*, _T2*>::value> {};
-
-template <class _T1, class _T2> struct __is_convertible<_T1, _T2* const, 1, 0>
-    : public integral_constant<bool, __is_convertible<typename remove_all_extents<_T1>::type*, _T2*const>::value> {};
-
-template <class _T1, class _T2> struct __is_convertible<_T1, _T2* volatile, 1, 0>
-    : public integral_constant<bool, __is_convertible<typename remove_all_extents<_T1>::type*, _T2*volatile>::value> {};
-
-template <class _T1, class _T2> struct __is_convertible<_T1, _T2* const volatile, 1, 0>
-    : public integral_constant<bool, __is_convertible<typename remove_all_extents<_T1>::type*, _T2*const volatile>::value> {};
-
-template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 2, 0>                : public false_type {};
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-template <class _T1>            struct __is_convertible<_T1, _T1&&, 2, 0>               : public true_type {};
-#endif
-template <class _T1>            struct __is_convertible<_T1, _T1&, 2, 0>               : public true_type {};
-template <class _T1>            struct __is_convertible<_T1, _T1*, 2, 0>               : public true_type {};
-template <class _T1>            struct __is_convertible<_T1, _T1*const, 2, 0>          : public true_type {};
-template <class _T1>            struct __is_convertible<_T1, _T1*volatile, 2, 0>       : public true_type {};
-template <class _T1>            struct __is_convertible<_T1, _T1*const volatile, 2, 0> : public true_type {};
-
-template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 3, 0> : public false_type {};
-
 template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 0, 1> : public false_type {};
 template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 1, 1> : public false_type {};
 template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 2, 1> : public false_type {};
@@ -2136,7 +2177,7 @@ move(_Tp&& __t) _NOEXCEPT
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 _Tp&&
-forward(typename std::remove_reference<_Tp>::type& __t) _NOEXCEPT
+forward(typename remove_reference<_Tp>::type& __t) _NOEXCEPT
 {
     return static_cast<_Tp&&>(__t);
 }
@@ -2144,9 +2185,9 @@ forward(typename std::remove_reference<_Tp>::type& __t) _NOEXCEPT
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 _Tp&&
-forward(typename std::remove_reference<_Tp>::type&& __t) _NOEXCEPT
+forward(typename remove_reference<_Tp>::type&& __t) _NOEXCEPT
 {
-    static_assert(!std::is_lvalue_reference<_Tp>::value,
+    static_assert(!is_lvalue_reference<_Tp>::value,
                   "Can not forward an rvalue as an lvalue.");
     return static_cast<_Tp&&>(__t);
 }
@@ -2172,7 +2213,7 @@ move(const _Tp& __t)
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 _Tp&
-forward(typename std::remove_reference<_Tp>::type& __t) _NOEXCEPT
+forward(typename remove_reference<_Tp>::type& __t) _NOEXCEPT
 {
     return __t;
 }
@@ -2691,6 +2732,15 @@ struct __member_pointer_traits
 //     typedef ... _FnType;
 };
 
+
+template <class _DecayedFp>
+struct __member_pointer_class_type {};
+
+template <class _Ret, class _ClassType>
+struct __member_pointer_class_type<_Ret _ClassType::*> {
+  typedef _ClassType type;
+};
+
 // result_of
 
 template <class _Callable> class result_of;
@@ -3918,7 +3968,12 @@ template <class _Tp> _LIBCPP_CONSTEXPR bool is_trivial_v
     = is_trivial<_Tp>::value;
 #endif
 
-#ifndef _LIBCPP_HAS_NO_VARIADICS
+template <class _Tp> struct __is_reference_wrapper_impl : public false_type {};
+template <class _Tp> struct __is_reference_wrapper_impl<reference_wrapper<_Tp> > : public true_type {};
+template <class _Tp> struct __is_reference_wrapper
+    : public __is_reference_wrapper_impl<typename remove_cv<_Tp>::type> {};
+
+#ifndef _LIBCPP_CXX03_LANG
 
 // Check for complete types
 
@@ -4006,8 +4061,6 @@ struct __check_complete<_Rp (_Class::*)(_Param...) const volatile>
 {
 };
 
-#if __has_feature(cxx_reference_qualified_functions)
-
 template <class _Rp, class _Class, class ..._Param>
 struct __check_complete<_Rp (_Class::*)(_Param...) &>
     : private __check_complete<_Class>
@@ -4056,125 +4109,257 @@ struct __check_complete<_Rp (_Class::*)(_Param...) const volatile&&>
 {
 };
 
-#endif
-
 template <class _Rp, class _Class>
 struct __check_complete<_Rp _Class::*>
     : private __check_complete<_Class>
 {
 };
 
+
+template <class _Fp, class _A0,
+         class _DecayFp = typename decay<_Fp>::type,
+         class _DecayA0 = typename decay<_A0>::type,
+         class _ClassT = typename __member_pointer_class_type<_DecayFp>::type>
+using __enable_if_bullet1 = typename enable_if
+    <
+        is_member_function_pointer<_DecayFp>::value
+        && is_base_of<_ClassT, _DecayA0>::value
+    >::type;
+
+template <class _Fp, class _A0,
+         class _DecayFp = typename decay<_Fp>::type,
+         class _DecayA0 = typename decay<_A0>::type>
+using __enable_if_bullet2 = typename enable_if
+    <
+        is_member_function_pointer<_DecayFp>::value
+        && __is_reference_wrapper<_DecayA0>::value
+    >::type;
+
+template <class _Fp, class _A0,
+         class _DecayFp = typename decay<_Fp>::type,
+         class _DecayA0 = typename decay<_A0>::type,
+         class _ClassT = typename __member_pointer_class_type<_DecayFp>::type>
+using __enable_if_bullet3 = typename enable_if
+    <
+        is_member_function_pointer<_DecayFp>::value
+        && !is_base_of<_ClassT, _DecayA0>::value
+        && !__is_reference_wrapper<_DecayA0>::value
+    >::type;
+
+template <class _Fp, class _A0,
+         class _DecayFp = typename decay<_Fp>::type,
+         class _DecayA0 = typename decay<_A0>::type,
+         class _ClassT = typename __member_pointer_class_type<_DecayFp>::type>
+using __enable_if_bullet4 = typename enable_if
+    <
+        is_member_object_pointer<_DecayFp>::value
+        && is_base_of<_ClassT, _DecayA0>::value
+    >::type;
+
+template <class _Fp, class _A0,
+         class _DecayFp = typename decay<_Fp>::type,
+         class _DecayA0 = typename decay<_A0>::type>
+using __enable_if_bullet5 = typename enable_if
+    <
+        is_member_object_pointer<_DecayFp>::value
+        && __is_reference_wrapper<_DecayA0>::value
+    >::type;
+
+template <class _Fp, class _A0,
+         class _DecayFp = typename decay<_Fp>::type,
+         class _DecayA0 = typename decay<_A0>::type,
+         class _ClassT = typename __member_pointer_class_type<_DecayFp>::type>
+using __enable_if_bullet6 = typename enable_if
+    <
+        is_member_object_pointer<_DecayFp>::value
+        && !is_base_of<_ClassT, _DecayA0>::value
+        && !__is_reference_wrapper<_DecayA0>::value
+    >::type;
+
 // __invoke forward declarations
 
 // fall back - none of the bullets
 
+#define _LIBCPP_INVOKE_RETURN(...) \
+    noexcept(noexcept(__VA_ARGS__)) -> decltype(__VA_ARGS__) \
+    { return __VA_ARGS__; }
+
+template <class ..._Args>
+auto __invoke(__any, _Args&& ...__args) -> __nat;
+
 template <class ..._Args>
+auto __invoke_constexpr(__any, _Args&& ...__args) -> __nat;
+
+// bullets 1, 2 and 3
+
+template <class _Fp, class _A0, class ..._Args,
+          class = __enable_if_bullet1<_Fp, _A0>>
+inline _LIBCPP_INLINE_VISIBILITY
 auto
-__invoke(__any, _Args&& ...__args)
-    -> __nat;
+__invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
+_LIBCPP_INVOKE_RETURN((_VSTD::forward<_A0>(__a0).*__f)(_VSTD::forward<_Args>(__args)...))
 
-// bullets 1 and 2
+template <class _Fp, class _A0, class ..._Args,
+          class = __enable_if_bullet1<_Fp, _A0>>
+inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR auto
+__invoke_constexpr(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
+_LIBCPP_INVOKE_RETURN((_VSTD::forward<_A0>(__a0).*__f)(_VSTD::forward<_Args>(__args)...))
 
 template <class _Fp, class _A0, class ..._Args,
-            class = typename enable_if
-            <
-                is_member_function_pointer<typename remove_reference<_Fp>::type>::value &&
-                is_base_of<typename remove_reference<typename __member_pointer_traits<typename remove_reference<_Fp>::type>::_ClassType>::type,
-                           typename remove_reference<_A0>::type>::value
-            >::type
-         >
-_LIBCPP_INLINE_VISIBILITY
+          class = __enable_if_bullet2<_Fp, _A0>>
+inline _LIBCPP_INLINE_VISIBILITY
 auto
 __invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
-    -> decltype((_VSTD::forward<_A0>(__a0).*__f)(_VSTD::forward<_Args>(__args)...));
+_LIBCPP_INVOKE_RETURN((__a0.get().*__f)(_VSTD::forward<_Args>(__args)...))
 
 template <class _Fp, class _A0, class ..._Args,
-            class = typename enable_if
-            <
-                is_member_function_pointer<typename remove_reference<_Fp>::type>::value &&
-                !is_base_of<typename remove_reference<typename __member_pointer_traits<typename remove_reference<_Fp>::type>::_ClassType>::type,
-                           typename remove_reference<_A0>::type>::value
-            >::type
-         >
-_LIBCPP_INLINE_VISIBILITY
+          class = __enable_if_bullet2<_Fp, _A0>>
+inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR auto
+__invoke_constexpr(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
+_LIBCPP_INVOKE_RETURN((__a0.get().*__f)(_VSTD::forward<_Args>(__args)...))
+
+template <class _Fp, class _A0, class ..._Args,
+          class = __enable_if_bullet3<_Fp, _A0>>
+inline _LIBCPP_INLINE_VISIBILITY
 auto
 __invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
-    -> decltype(((*_VSTD::forward<_A0>(__a0)).*__f)(_VSTD::forward<_Args>(__args)...));
+_LIBCPP_INVOKE_RETURN(((*_VSTD::forward<_A0>(__a0)).*__f)(_VSTD::forward<_Args>(__args)...))
+
+template <class _Fp, class _A0, class ..._Args,
+          class = __enable_if_bullet3<_Fp, _A0>>
+inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR auto
+__invoke_constexpr(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
+_LIBCPP_INVOKE_RETURN(((*_VSTD::forward<_A0>(__a0)).*__f)(_VSTD::forward<_Args>(__args)...))
 
-// bullets 3 and 4
+// bullets 4, 5 and 6
 
 template <class _Fp, class _A0,
-            class = typename enable_if
-            <
-                is_member_object_pointer<typename remove_reference<_Fp>::type>::value &&
-                is_base_of<typename __member_pointer_traits<typename remove_reference<_Fp>::type>::_ClassType,
-                           typename remove_reference<_A0>::type>::value
-            >::type
-         >
-_LIBCPP_INLINE_VISIBILITY
+          class = __enable_if_bullet4<_Fp, _A0>>
+inline _LIBCPP_INLINE_VISIBILITY
 auto
 __invoke(_Fp&& __f, _A0&& __a0)
-    -> decltype(_VSTD::forward<_A0>(__a0).*__f);
+_LIBCPP_INVOKE_RETURN(_VSTD::forward<_A0>(__a0).*__f)
+
+template <class _Fp, class _A0,
+          class = __enable_if_bullet4<_Fp, _A0>>
+inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR auto
+__invoke_constexpr(_Fp&& __f, _A0&& __a0)
+_LIBCPP_INVOKE_RETURN(_VSTD::forward<_A0>(__a0).*__f)
 
 template <class _Fp, class _A0,
-            class = typename enable_if
-            <
-                is_member_object_pointer<typename remove_reference<_Fp>::type>::value &&
-                !is_base_of<typename __member_pointer_traits<typename remove_reference<_Fp>::type>::_ClassType,
-                           typename remove_reference<_A0>::type>::value
-            >::type
-         >
-_LIBCPP_INLINE_VISIBILITY
+          class = __enable_if_bullet5<_Fp, _A0>>
+inline _LIBCPP_INLINE_VISIBILITY
 auto
 __invoke(_Fp&& __f, _A0&& __a0)
-    -> decltype((*_VSTD::forward<_A0>(__a0)).*__f);
+_LIBCPP_INVOKE_RETURN(__a0.get().*__f)
 
-// bullet 5
+template <class _Fp, class _A0,
+          class = __enable_if_bullet5<_Fp, _A0>>
+inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR auto
+__invoke_constexpr(_Fp&& __f, _A0&& __a0)
+_LIBCPP_INVOKE_RETURN(__a0.get().*__f)
+
+template <class _Fp, class _A0,
+          class = __enable_if_bullet6<_Fp, _A0>>
+inline _LIBCPP_INLINE_VISIBILITY
+auto
+__invoke(_Fp&& __f, _A0&& __a0)
+_LIBCPP_INVOKE_RETURN((*_VSTD::forward<_A0>(__a0)).*__f)
+
+template <class _Fp, class _A0,
+          class = __enable_if_bullet6<_Fp, _A0>>
+inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR auto
+__invoke_constexpr(_Fp&& __f, _A0&& __a0)
+_LIBCPP_INVOKE_RETURN((*_VSTD::forward<_A0>(__a0)).*__f)
+
+// bullet 7
 
 template <class _Fp, class ..._Args>
-_LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY
 auto
 __invoke(_Fp&& __f, _Args&& ...__args)
-    -> decltype(_VSTD::forward<_Fp>(__f)(_VSTD::forward<_Args>(__args)...));
+_LIBCPP_INVOKE_RETURN(_VSTD::forward<_Fp>(__f)(_VSTD::forward<_Args>(__args)...))
+
+template <class _Fp, class ..._Args>
+inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR auto
+__invoke_constexpr(_Fp&& __f, _Args&& ...__args)
+_LIBCPP_INVOKE_RETURN(_VSTD::forward<_Fp>(__f)(_VSTD::forward<_Args>(__args)...))
+
+#undef _LIBCPP_INVOKE_RETURN
 
 // __invokable
 
-template <class _Fp, class ..._Args>
-struct __invokable_imp
+template <class _Ret, class _Fp, class ..._Args>
+struct __invokable_r
     : private __check_complete<_Fp>
 {
-    typedef decltype(
-            __invoke(_VSTD::declval<_Fp>(), _VSTD::declval<_Args>()...)
-                    ) type;
-    static const bool value = !is_same<type, __nat>::value;
+    using _Result = decltype(
+        _VSTD::__invoke(_VSTD::declval<_Fp>(), _VSTD::declval<_Args>()...));
+
+    static const bool value =
+        conditional<
+            !is_same<_Result, __nat>::value,
+            typename conditional<
+                is_void<_Ret>::value,
+                true_type,
+                is_convertible<_Result, _Ret>
+            >::type,
+            false_type
+        >::type::value;
 };
 
 template <class _Fp, class ..._Args>
-struct __invokable
-    : public integral_constant<bool,
-          __invokable_imp<_Fp, _Args...>::value>
-{
-};
+using __invokable = __invokable_r<void, _Fp, _Args...>;
 
-// __invoke_of
+template <bool _IsInvokable, bool _IsCVVoid, class _Ret, class _Fp, class ..._Args>
+struct __nothrow_invokable_r_imp {
+  static const bool value = false;
+};
 
-template <bool _Invokable, class _Fp, class ..._Args>
-struct __invoke_of_imp  // false
+template <class _Ret, class _Fp, class ..._Args>
+struct __nothrow_invokable_r_imp<true, false, _Ret, _Fp, _Args...>
 {
+    typedef __nothrow_invokable_r_imp _ThisT;
+
+    template <class _Tp>
+    static void __test_noexcept(_Tp) noexcept;
+
+    static const bool value = noexcept(_ThisT::__test_noexcept<_Ret>(
+        _VSTD::__invoke(_VSTD::declval<_Fp>(), _VSTD::declval<_Args>()...)));
 };
 
-template <class _Fp, class ..._Args>
-struct __invoke_of_imp<true, _Fp, _Args...>
+template <class _Ret, class _Fp, class ..._Args>
+struct __nothrow_invokable_r_imp<true, true, _Ret, _Fp, _Args...>
 {
-    typedef typename __invokable_imp<_Fp, _Args...>::type type;
+    static const bool value = noexcept(
+        _VSTD::__invoke(_VSTD::declval<_Fp>(), _VSTD::declval<_Args>()...));
 };
 
+template <class _Ret, class _Fp, class ..._Args>
+using __nothrow_invokable_r =
+    __nothrow_invokable_r_imp<
+            __invokable_r<_Ret, _Fp, _Args...>::value,
+            is_void<_Ret>::value,
+            _Ret, _Fp, _Args...
+    >;
+
 template <class _Fp, class ..._Args>
 struct __invoke_of
-    : public __invoke_of_imp<__invokable<_Fp, _Args...>::value, _Fp, _Args...>
+    : public enable_if<
+        __invokable<_Fp, _Args...>::value,
+        typename __invokable_r<void, _Fp, _Args...>::_Result>
 {
 };
 
+// result_of
+
 template <class _Fp, class ..._Args>
 class _LIBCPP_TYPE_VIS_ONLY result_of<_Fp(_Args...)>
     : public __invoke_of<_Fp, _Args...>
@@ -4185,7 +4370,39 @@ class _LIBCPP_TYPE_VIS_ONLY result_of<_Fp(_Args...)>
 template <class _Tp> using result_of_t = typename result_of<_Tp>::type;
 #endif
 
-#endif  // _LIBCPP_HAS_NO_VARIADICS
+#if _LIBCPP_STD_VER > 14
+
+// is_callable
+
+template <class _Fn, class _Ret = void>
+struct _LIBCPP_TYPE_VIS_ONLY is_callable;
+
+template <class _Fn, class ..._Args, class _Ret>
+struct _LIBCPP_TYPE_VIS_ONLY is_callable<_Fn(_Args...), _Ret>
+    : integral_constant<bool, __invokable_r<_Ret, _Fn, _Args...>::value> {};
+
+template <class _Fn, class _Ret = void>
+constexpr bool is_callable_v = is_callable<_Fn, _Ret>::value;
+
+// is_nothrow_callable
+
+template <class _Fn, class _Ret = void>
+struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_callable;
+
+template <class _Fn, class ..._Args, class _Ret>
+struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_callable<_Fn(_Args...), _Ret>
+    : integral_constant<bool, __nothrow_invokable_r<_Ret, _Fn, _Args...>::value>
+{};
+
+template <class _Fn, class _Ret = void>
+constexpr bool is_nothrow_callable_v = is_nothrow_callable<_Fn, _Ret>::value;
+
+#endif // _LIBCPP_STD_VER > 14
+
+#endif  // !defined(_LIBCPP_CXX03_LANG)
+
+template <class _Tp> struct __is_swappable;
+template <class _Tp> struct __is_nothrow_swappable;
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -4206,6 +4423,13 @@ swap(_Tp& __x, _Tp& __y) _NOEXCEPT_(is_nothrow_move_constructible<_Tp>::value &&
     __y = _VSTD::move(__t);
 }
 
+template<class _Tp, size_t _Np>
+inline _LIBCPP_INLINE_VISIBILITY
+typename enable_if<
+    __is_swappable<_Tp>::value
+>::type
+swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np]) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value);
+
 template <class _ForwardIterator1, class _ForwardIterator2>
 inline _LIBCPP_INLINE_VISIBILITY
 void
@@ -4221,55 +4445,108 @@ iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
 
 namespace __detail
 {
+// ALL generic swap overloads MUST already have a declaration available at this point.
 
-using _VSTD::swap;
-__nat swap(__any, __any);
-
-template <class _Tp>
-struct __swappable
+template <class _Tp, class _Up = _Tp,
+          bool _NotVoid = !is_void<_Tp>::value && !is_void<_Up>::value>
+struct __swappable_with
 {
-    typedef decltype(swap(_VSTD::declval<_Tp&>(), _VSTD::declval<_Tp&>())) type;
-    static const bool value = !is_same<type, __nat>::value;
+    template <class _LHS, class _RHS>
+    static decltype(swap(_VSTD::declval<_LHS>(), _VSTD::declval<_RHS>()))
+    __test_swap(int);
+    template <class, class>
+    static __nat __test_swap(long);
+
+    // Extra parens are needed for the C++03 definition of decltype.
+    typedef decltype((__test_swap<_Tp, _Up>(0))) __swap1;
+    typedef decltype((__test_swap<_Up, _Tp>(0))) __swap2;
+
+    static const bool value = !is_same<__swap1, __nat>::value
+                           && !is_same<__swap2, __nat>::value;
 };
 
+template <class _Tp, class _Up>
+struct __swappable_with<_Tp, _Up,  false> : false_type {};
+
+template <class _Tp, class _Up = _Tp, bool _Swappable = __swappable_with<_Tp, _Up>::value>
+struct __nothrow_swappable_with {
+  static const bool value =
+#ifndef _LIBCPP_HAS_NO_NOEXCEPT
+      noexcept(swap(_VSTD::declval<_Tp>(), _VSTD::declval<_Up>()))
+  &&  noexcept(swap(_VSTD::declval<_Up>(), _VSTD::declval<_Tp>()));
+#else
+      false;
+#endif
+};
+
+template <class _Tp, class _Up>
+struct __nothrow_swappable_with<_Tp, _Up, false> : false_type {};
+
 }  // __detail
 
 template <class _Tp>
 struct __is_swappable
-    : public integral_constant<bool, __detail::__swappable<_Tp>::value>
+    : public integral_constant<bool, __detail::__swappable_with<_Tp&>::value>
 {
 };
 
-#if __has_feature(cxx_noexcept) || (_GNUC_VER >= 407 && __cplusplus >= 201103L)
-
-template <bool, class _Tp>
-struct __is_nothrow_swappable_imp
-    : public integral_constant<bool, noexcept(swap(_VSTD::declval<_Tp&>(),
-                                                   _VSTD::declval<_Tp&>()))>
+template <class _Tp>
+struct __is_nothrow_swappable
+    : public integral_constant<bool, __detail::__nothrow_swappable_with<_Tp&>::value>
 {
 };
 
-template <class _Tp>
-struct __is_nothrow_swappable_imp<false, _Tp>
-    : public false_type
+#if _LIBCPP_STD_VER > 14
+
+template <class _Tp, class _Up>
+struct _LIBCPP_TYPE_VIS_ONLY is_swappable_with
+    : public integral_constant<bool, __detail::__swappable_with<_Tp, _Up>::value>
 {
 };
 
 template <class _Tp>
-struct __is_nothrow_swappable
-    : public __is_nothrow_swappable_imp<__is_swappable<_Tp>::value, _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY is_swappable
+    : public conditional<
+        __is_referenceable<_Tp>::value,
+        is_swappable_with<
+            typename add_lvalue_reference<_Tp>::type,
+            typename add_lvalue_reference<_Tp>::type>,
+        false_type
+    >::type
 {
 };
 
-#else  // __has_feature(cxx_noexcept)
+template <class _Tp, class _Up>
+struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_swappable_with
+    : public integral_constant<bool, __detail::__nothrow_swappable_with<_Tp, _Up>::value>
+{
+};
 
 template <class _Tp>
-struct __is_nothrow_swappable
-    : public false_type
+struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_swappable
+    : public conditional<
+        __is_referenceable<_Tp>::value,
+        is_nothrow_swappable_with<
+            typename add_lvalue_reference<_Tp>::type,
+            typename add_lvalue_reference<_Tp>::type>,
+        false_type
+    >::type
 {
 };
 
-#endif  // __has_feature(cxx_noexcept)
+template <class _Tp, class _Up>
+constexpr bool is_swappable_with_v = is_swappable_with<_Tp, _Up>::value;
+
+template <class _Tp>
+constexpr bool is_swappable_v = is_swappable<_Tp>::value;
+
+template <class _Tp, class _Up>
+constexpr bool is_nothrow_swappable_with_v = is_nothrow_swappable_with<_Tp, _Up>::value;
+
+template <class _Tp>
+constexpr bool is_nothrow_swappable_v = is_nothrow_swappable<_Tp>::value;
+
+#endif // _LIBCPP_STD_VER > 14
 
 #ifdef _LIBCPP_UNDERLYING_TYPE
 
@@ -4296,7 +4573,7 @@ struct underlying_type
 #endif // _LIBCPP_UNDERLYING_TYPE
 
 
-template <class _Tp, bool = std::is_enum<_Tp>::value>
+template <class _Tp, bool = is_enum<_Tp>::value>
 struct __sfinae_underlying_type
 {
     typedef typename underlying_type<_Tp>::type type;
@@ -4389,6 +4666,39 @@ template<class _Tp> constexpr bool negation_v = negation<_Tp>::value;
 # endif // _LIBCPP_HAS_NO_VARIADICS
 #endif  // _LIBCPP_STD_VER > 14
 
+// These traits are used in __tree and __hash_table
+#ifndef _LIBCPP_CXX03_LANG
+struct __extract_key_fail_tag {};
+struct __extract_key_self_tag {};
+struct __extract_key_first_tag {};
+
+template <class _ValTy, class _Key,
+          class _RawValTy = typename __unconstref<_ValTy>::type>
+struct __can_extract_key
+    : conditional<is_same<_RawValTy, _Key>::value, __extract_key_self_tag,
+                  __extract_key_fail_tag>::type {};
+
+template <class _Pair, class _Key, class _First, class _Second>
+struct __can_extract_key<_Pair, _Key, pair<_First, _Second>>
+    : conditional<is_same<typename remove_const<_First>::type, _Key>::value,
+                  __extract_key_first_tag, __extract_key_fail_tag>::type {};
+
+// __can_extract_map_key uses true_type/false_type instead of the tags.
+// It returns true if _Key != _ContainerValueTy (the container is a map not a set)
+// and _ValTy == _Key.
+template <class _ValTy, class _Key, class _ContainerValueTy,
+          class _RawValTy = typename __unconstref<_ValTy>::type>
+struct __can_extract_map_key
+    : integral_constant<bool, is_same<_RawValTy, _Key>::value> {};
+
+// This specialization returns __extract_key_fail_tag for non-map containers
+// because _Key == _ContainerValueTy
+template <class _ValTy, class _Key, class _RawValTy>
+struct __can_extract_map_key<_ValTy, _Key, _Key, _RawValTy>
+    : false_type {};
+
+#endif
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_TYPE_TRAITS
diff --git a/include/unordered_map b/include/unordered_map
index 85a54a7b6ddb..bf64ad66f39a 100644
--- a/include/unordered_map
+++ b/include/unordered_map
@@ -369,6 +369,7 @@ template <class Key, class T, class Hash, class Pred, class Alloc>
 #include <__hash_table>
 #include <functional>
 #include <stdexcept>
+#include <tuple>
 
 #include <__debug>
 
@@ -413,7 +414,6 @@ template <class _Key, class _Cp, class _Hash>
 class __unordered_map_hasher<_Key, _Cp, _Hash, false>
 {
     _Hash __hash_;
-
 public:
     _LIBCPP_INLINE_VISIBILITY
     __unordered_map_hasher()
@@ -487,7 +487,6 @@ template <class _Key, class _Cp, class _Pred>
 class __unordered_map_equal<_Key, _Cp, _Pred, false>
 {
     _Pred __pred_;
-
 public:
     _LIBCPP_INLINE_VISIBILITY
     __unordered_map_equal()
@@ -531,12 +530,11 @@ class __hash_map_node_destructor
 {
     typedef _Alloc                              allocator_type;
     typedef allocator_traits<allocator_type>    __alloc_traits;
-    typedef typename __alloc_traits::value_type::value_type value_type;
+
 public:
-    typedef typename __alloc_traits::pointer    pointer;
+
+    typedef typename __alloc_traits::pointer       pointer;
 private:
-    typedef typename value_type::value_type::first_type     first_type;
-    typedef typename value_type::value_type::second_type    second_type;
 
     allocator_type& __na_;
 
@@ -586,8 +584,7 @@ public:
     }
 };
 
-#if __cplusplus >= 201103L
-
+#ifndef _LIBCPP_CXX03_LANG
 template <class _Key, class _Tp>
 union __hash_value_type
 {
@@ -599,19 +596,6 @@ union __hash_value_type
     value_type __cc;
     __nc_value_type __nc;
 
-    template <class ..._Args>
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_value_type(_Args&& ...__args)
-        : __cc(std::forward<_Args>(__args)...) {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_value_type(const __hash_value_type& __v)
-        : __cc(__v.__cc) {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_value_type(__hash_value_type&& __v)
-        : __nc(_VSTD::move(__v.__nc)) {}
-
     _LIBCPP_INLINE_VISIBILITY
     __hash_value_type& operator=(const __hash_value_type& __v)
         {__nc = __v.__cc; return *this;}
@@ -620,8 +604,23 @@ union __hash_value_type
     __hash_value_type& operator=(__hash_value_type&& __v)
         {__nc = _VSTD::move(__v.__nc); return *this;}
 
+    template <class _ValueTp,
+              class = typename enable_if<
+                    __is_same_uncvref<_ValueTp, value_type>::value
+                 >::type
+             >
     _LIBCPP_INLINE_VISIBILITY
-    ~__hash_value_type() {__cc.~value_type();}
+    __hash_value_type& operator=(_ValueTp&& __v) {
+        __nc = _VSTD::forward<_ValueTp>(__v); return *this;
+    }
+
+private:
+    __hash_value_type(const __hash_value_type& __v) = delete;
+    __hash_value_type(__hash_value_type&& __v) = delete;
+    template <class ..._Args>
+    explicit __hash_value_type(_Args&& ...__args) = delete;
+
+    ~__hash_value_type() = delete;
 };
 
 #else
@@ -635,18 +634,8 @@ struct __hash_value_type
 
     value_type __cc;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_value_type() {}
-
-    template <class _A0>
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_value_type(const _A0& __a0)
-        : __cc(__a0) {}
-
-    template <class _A0, class _A1>
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_value_type(const _A0& __a0, const _A1& __a1)
-        : __cc(__a0, __a1) {}
+private:
+   ~__hash_value_type();
 };
 
 #endif
@@ -656,15 +645,14 @@ class _LIBCPP_TYPE_VIS_ONLY __hash_map_iterator
 {
     _HashIterator __i_;
 
-    typedef const typename _HashIterator::value_type::value_type::first_type key_type;
-    typedef typename _HashIterator::value_type::value_type::second_type      mapped_type;
+    typedef  __hash_node_types_from_iterator<_HashIterator> _NodeTypes;
+
 public:
     typedef forward_iterator_tag                                 iterator_category;
-    typedef pair<key_type, mapped_type>                          value_type;
-    typedef typename _HashIterator::difference_type              difference_type;
+    typedef typename _NodeTypes::__map_value_type                value_type;
+    typedef typename _NodeTypes::difference_type                 difference_type;
     typedef value_type&                                          reference;
-    typedef typename __rebind_pointer<typename _HashIterator::pointer, value_type>::type
-        pointer;
+    typedef typename _NodeTypes::__map_value_type_pointer       pointer;
 
     _LIBCPP_INLINE_VISIBILITY
     __hash_map_iterator() _NOEXCEPT {}
@@ -706,15 +694,14 @@ class _LIBCPP_TYPE_VIS_ONLY __hash_map_const_iterator
 {
     _HashIterator __i_;
 
-    typedef const typename _HashIterator::value_type::value_type::first_type key_type;
-    typedef typename _HashIterator::value_type::value_type::second_type      mapped_type;
+    typedef  __hash_node_types_from_iterator<_HashIterator> _NodeTypes;
+
 public:
     typedef forward_iterator_tag                                 iterator_category;
-    typedef pair<key_type, mapped_type>                          value_type;
-    typedef typename _HashIterator::difference_type              difference_type;
+    typedef typename _NodeTypes::__map_value_type                value_type;
+    typedef typename _NodeTypes::difference_type                 difference_type;
     typedef const value_type&                                    reference;
-    typedef typename __rebind_pointer<typename _HashIterator::pointer, const value_type>::type
-        pointer;
+    typedef typename _NodeTypes::__const_map_value_type_pointer  pointer;
 
     _LIBCPP_INLINE_VISIBILITY
     __hash_map_const_iterator() _NOEXCEPT {}
@@ -785,6 +772,7 @@ private:
 
     __table __table_;
 
+    typedef typename __table::_NodeTypes                   _NodeTypes;
     typedef typename __table::__node_pointer               __node_pointer;
     typedef typename __table::__node_const_pointer         __node_const_pointer;
     typedef typename __table::__node_traits                __node_traits;
@@ -793,11 +781,14 @@ private:
     typedef __hash_map_node_destructor<__node_allocator>   _Dp;
     typedef unique_ptr<__node, _Dp>                         __node_holder;
     typedef allocator_traits<allocator_type>               __alloc_traits;
+
+    static_assert((is_same<typename __table::__container_value_type, value_type>::value), "");
+    static_assert((is_same<typename __table::__node_value_type, __value_type>::value), "");
 public:
     typedef typename __alloc_traits::pointer         pointer;
     typedef typename __alloc_traits::const_pointer   const_pointer;
-    typedef typename __alloc_traits::size_type       size_type;
-    typedef typename __alloc_traits::difference_type difference_type;
+    typedef typename __table::size_type              size_type;
+    typedef typename __table::difference_type        difference_type;
 
     typedef __hash_map_iterator<typename __table::iterator>       iterator;
     typedef __hash_map_const_iterator<typename __table::const_iterator> const_iterator;
@@ -828,10 +819,12 @@ public:
                       size_type __n, const hasher& __hf,
                       const key_equal& __eql,
                       const allocator_type& __a);
+    _LIBCPP_INLINE_VISIBILITY
     explicit unordered_map(const allocator_type& __a);
     unordered_map(const unordered_map& __u);
     unordered_map(const unordered_map& __u, const allocator_type& __a);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     unordered_map(unordered_map&& __u)
         _NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
     unordered_map(unordered_map&& __u, const allocator_type& __a);
@@ -872,7 +865,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     unordered_map& operator=(const unordered_map& __u)
     {
-#if __cplusplus >= 201103L
+#ifndef _LIBCPP_CXX03_LANG
         __table_ = __u.__table_;
 #else
         if (this != &__u) {
@@ -887,10 +880,12 @@ public:
         return *this;
     }
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     unordered_map& operator=(unordered_map&& __u)
         _NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
 #endif
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+    _LIBCPP_INLINE_VISIBILITY
     unordered_map& operator=(initializer_list<value_type> __il);
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
@@ -918,189 +913,162 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     const_iterator cend()   const _NOEXCEPT {return __table_.end();}
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#ifndef _LIBCPP_HAS_NO_VARIADICS
+    _LIBCPP_INLINE_VISIBILITY
+    pair<iterator, bool> insert(const value_type& __x)
+        {return __table_.__insert_unique(__x);}
 
-    template <class... _Args>
-        pair<iterator, bool> emplace(_Args&&... __args);
+    iterator insert(const_iterator __p, const value_type& __x) {
+#if _LIBCPP_DEBUG_LEVEL >= 2
+        _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
+            "unordered_map::insert(const_iterator, const value_type&) called with an iterator not"
+            " referring to this unordered_map");
+#endif
+        return insert(__x).first;
+    }
 
-    template <class... _Args>
+    template <class _InputIterator>
         _LIBCPP_INLINE_VISIBILITY
+        void insert(_InputIterator __first, _InputIterator __last);
+
+#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+    _LIBCPP_INLINE_VISIBILITY
+    void insert(initializer_list<value_type> __il)
+        {insert(__il.begin(), __il.end());}
+#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+
+#ifndef _LIBCPP_CXX03_LANG
+    _LIBCPP_INLINE_VISIBILITY
+    pair<iterator, bool> insert(value_type&& __x)
+        {return __table_.__insert_unique(_VSTD::move(__x));}
+
+    iterator insert(const_iterator __p, value_type&& __x) {
 #if _LIBCPP_DEBUG_LEVEL >= 2
-        iterator emplace_hint(const_iterator __p, _Args&&... __args)
-        {
-            _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
-                "unordered_map::emplace_hint(const_iterator, args...) called with an iterator not"
-                " referring to this unordered_map");
-            return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...).first;
-        }
-#else
-        iterator emplace_hint(const_iterator, _Args&&... __args)
-            {return emplace(_VSTD::forward<_Args>(__args)...).first;}
+        _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
+            "unordered_map::insert(const_iterator, const value_type&) called with an iterator not"
+            " referring to this unordered_map");
 #endif
-#endif  // _LIBCPP_HAS_NO_VARIADICS
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, bool> insert(const value_type& __x)
-        {return __table_.__insert_unique(__x);}
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+        return __table_.__insert_unique(_VSTD::move(__x)).first;
+    }
+
     template <class _Pp,
               class = typename enable_if<is_constructible<value_type, _Pp>::value>::type>
         _LIBCPP_INLINE_VISIBILITY
         pair<iterator, bool> insert(_Pp&& __x)
             {return __table_.__insert_unique(_VSTD::forward<_Pp>(__x));}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
-#if _LIBCPP_DEBUG_LEVEL >= 2
-    iterator insert(const_iterator __p, const value_type& __x)
-        {
-            _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
-                "unordered_map::insert(const_iterator, const value_type&) called with an iterator not"
-                " referring to this unordered_map");
-            return insert(__x).first;
-        }
-#else
-    iterator insert(const_iterator, const value_type& __x)
-        {return insert(__x).first;}
-#endif
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+
     template <class _Pp,
               class = typename enable_if<is_constructible<value_type, _Pp>::value>::type>
         _LIBCPP_INLINE_VISIBILITY
-#if _LIBCPP_DEBUG_LEVEL >= 2
         iterator insert(const_iterator __p, _Pp&& __x)
         {
+#if _LIBCPP_DEBUG_LEVEL >= 2
             _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
                 "unordered_map::insert(const_iterator, value_type&&) called with an iterator not"
                 " referring to this unordered_map");
+#endif
             return insert(_VSTD::forward<_Pp>(__x)).first;
         }
-#else
-        iterator insert(const_iterator, _Pp&& __x)
-            {return insert(_VSTD::forward<_Pp>(__x)).first;}
-#endif
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    template <class _InputIterator>
-        void insert(_InputIterator __first, _InputIterator __last);
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+
+    template <class... _Args>
     _LIBCPP_INLINE_VISIBILITY
-    void insert(initializer_list<value_type> __il)
-        {insert(__il.begin(), __il.end());}
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+    pair<iterator, bool> emplace(_Args&&... __args) {
+        return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...);
+    }
+
+    template <class... _Args>
+    _LIBCPP_INLINE_VISIBILITY
+    iterator emplace_hint(const_iterator __p, _Args&&... __args) {
+#if _LIBCPP_DEBUG_LEVEL >= 2
+        _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
+            "unordered_map::emplace_hint(const_iterator, args...) called with an iterator not"
+            " referring to this unordered_map");
+#endif
+        return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...).first;
+    }
+
+#endif  // _LIBCPP_CXX03_LANG
 
 #if _LIBCPP_STD_VER > 14
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#ifndef _LIBCPP_HAS_NO_VARIADICS
     template <class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         pair<iterator, bool> try_emplace(const key_type& __k, _Args&&... __args)
     {
-        iterator __p = __table_.find(__k);
-        if ( __p != end())
-            return _VSTD::make_pair(__p, false);
-        else
-            return _VSTD::make_pair(
-                      emplace_hint(__p, 
-                        _VSTD::piecewise_construct, _VSTD::forward_as_tuple(__k), 
-                        _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)),
-                      true);
+        return __table_.__emplace_unique_key_args(__k, _VSTD::piecewise_construct,
+            _VSTD::forward_as_tuple(__k),
+            _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...));
     }
 
     template <class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         pair<iterator, bool> try_emplace(key_type&& __k, _Args&&... __args)
     {
-        iterator __p = __table_.find(__k);
-        if ( __p != end())
-            return _VSTD::make_pair(__p, false);
-        else
-            return _VSTD::make_pair(
-                      emplace_hint(__p, 
-                        _VSTD::piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__k)), 
-                        _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)),
-                      true);
+        return __table_.__emplace_unique_key_args(__k, _VSTD::piecewise_construct,
+            _VSTD::forward_as_tuple(_VSTD::move(__k)),
+            _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...));
     }
 
     template <class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         iterator try_emplace(const_iterator __h, const key_type& __k, _Args&&... __args)
     {
-        iterator __p = __table_.find(__k);
-        if ( __p != end())
-            return __p;
-        else
-            return emplace_hint(__h, 
-                      _VSTD::piecewise_construct, _VSTD::forward_as_tuple(__k), 
-                      _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...));
+#if _LIBCPP_DEBUG_LEVEL >= 2
+        _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
+            "unordered_map::try_emplace(const_iterator, key, args...) called with an iterator not"
+            " referring to this unordered_map");
+#endif
+            return try_emplace(__k, _VSTD::forward<_Args>(__args)...).first;
     }
 
     template <class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         iterator try_emplace(const_iterator __h, key_type&& __k, _Args&&... __args)
     {
-        iterator __p = __table_.find(__k);
-        if ( __p != end())
-            return __p;
-        else
-            return emplace_hint(__h, 
-                      _VSTD::piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__k)), 
-                      _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...));
+#if _LIBCPP_DEBUG_LEVEL >= 2
+        _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
+            "unordered_map::try_emplace(const_iterator, key, args...) called with an iterator not"
+            " referring to this unordered_map");
+#endif
+        return try_emplace(_VSTD::move(__k), _VSTD::forward<_Args>(__args)...).first;
     }
 
     template <class _Vp>
         _LIBCPP_INLINE_VISIBILITY
         pair<iterator, bool> insert_or_assign(const key_type& __k, _Vp&& __v)
     {
-        iterator __p = __table_.find(__k);
-        if ( __p != end())
-        {
-            __p->second = _VSTD::move(__v);
-            return _VSTD::make_pair(__p, false);
+        pair<iterator, bool> __res = __table_.__emplace_unique_key_args(__k,
+            __k, _VSTD::forward<_Vp>(__v));
+        if (!__res.second) {
+            __res.first->second = _VSTD::forward<_Vp>(__v);
         }
-        return _VSTD::make_pair(emplace_hint(__p, __k, _VSTD::forward<_Vp>(__v)), true);
+        return __res;
     }
-        
+
     template <class _Vp>
         _LIBCPP_INLINE_VISIBILITY
         pair<iterator, bool> insert_or_assign(key_type&& __k, _Vp&& __v)
     {
-        iterator __p = __table_.find(__k);
-        if ( __p != end())
-        {
-            __p->second = _VSTD::move(__v);
-            return _VSTD::make_pair(__p, false);
+        pair<iterator, bool> __res = __table_.__emplace_unique_key_args(__k,
+            _VSTD::move(__k), _VSTD::forward<_Vp>(__v));
+        if (!__res.second) {
+            __res.first->second = _VSTD::forward<_Vp>(__v);
         }
-        return _VSTD::make_pair(emplace_hint(__p, _VSTD::forward<key_type>(__k), _VSTD::forward<_Vp>(__v)), true);
+        return __res;
     }
 
     template <class _Vp>
         _LIBCPP_INLINE_VISIBILITY
         iterator insert_or_assign(const_iterator __h, const key_type& __k, _Vp&& __v)
      {
-        iterator __p = __table_.find(__k);
-        if ( __p != end())
-        {
-            __p->second = _VSTD::move(__v);
-            return __p;
-        }
-        return emplace_hint(__h, __k, _VSTD::forward<_Vp>(__v));
+          return insert_or_assign(__k, _VSTD::forward<_Vp>(__v)).first;
      }
 
     template <class _Vp>
         _LIBCPP_INLINE_VISIBILITY
         iterator insert_or_assign(const_iterator __h, key_type&& __k, _Vp&& __v)
      {
-        iterator __p = __table_.find(__k);
-        if ( __p != end())
-        {
-            __p->second = _VSTD::move(__v);
-            return __p;
-        }
-        return emplace_hint(__h, _VSTD::forward<key_type>(__k), _VSTD::forward<_Vp>(__v));
+        return insert_or_assign(_VSTD::move(__k), _VSTD::forward<_Vp>(__v)).first;
      }
 #endif
-#endif
-#endif
 
     _LIBCPP_INLINE_VISIBILITY
     iterator erase(const_iterator __p) {return __table_.erase(__p.__i_);}
@@ -1140,7 +1108,7 @@ public:
         {return __table_.__equal_range_unique(__k);}
 
     mapped_type& operator[](const key_type& __k);
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifndef _LIBCPP_CXX03_LANG
     mapped_type& operator[](key_type&& __k);
 #endif
 
@@ -1196,18 +1164,10 @@ public:
 #endif  // _LIBCPP_DEBUG_LEVEL >= 2
 
 private:
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    __node_holder __construct_node();
-    template <class _A0>
-        __node_holder
-         __construct_node(_A0&& __a0);
-    __node_holder __construct_node_with_key(key_type&& __k);
-#ifndef _LIBCPP_HAS_NO_VARIADICS
-    template <class _A0, class _A1, class ..._Args>
-        __node_holder __construct_node(_A0&& __a0, _A1&& __a1, _Args&& ...__args);
-#endif  // _LIBCPP_HAS_NO_VARIADICS
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+
+#ifdef _LIBCPP_CXX03_LANG
     __node_holder __construct_node_with_key(const key_type& __k);
+#endif
 };
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
@@ -1234,7 +1194,7 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
         const allocator_type& __a)
     : __table_(__a)
@@ -1310,7 +1270,7 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
         unordered_map&& __u)
     _NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
@@ -1333,10 +1293,10 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
     if (__a != __u.get_allocator())
     {
         iterator __i = __u.begin();
-        while (__u.size() != 0)
-            __table_.__insert_unique(
-                _VSTD::move(__u.__table_.remove((__i++).__i_)->__value_)
-                                    );
+        while (__u.size() != 0) {
+            __table_.__emplace_unique(_VSTD::move(
+                __u.__table_.remove((__i++).__i_)->__value_.__nc));
+        }
     }
 #if _LIBCPP_DEBUG_LEVEL >= 2
     else
@@ -1389,7 +1349,7 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>&
 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(unordered_map&& __u)
     _NOEXCEPT_(is_nothrow_move_assignable<__table>::value)
@@ -1403,7 +1363,7 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(unordered_map&& __u)
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>&
 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(
         initializer_list<value_type> __il)
@@ -1414,81 +1374,7 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(
 
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
-template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder
-unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node()
-{
-    __node_allocator& __na = __table_.__node_alloc();
-    __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
-    __node_traits::construct(__na, _VSTD::addressof(__h->__value_));
-    __h.get_deleter().__first_constructed = true;
-    __h.get_deleter().__second_constructed = true;
-    return __h;
-}
-
-template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-template <class _A0>
-typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder
-unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(_A0&& __a0)
-{
-    __node_allocator& __na = __table_.__node_alloc();
-    __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
-    __node_traits::construct(__na, _VSTD::addressof(__h->__value_),
-                             _VSTD::forward<_A0>(__a0));
-    __h.get_deleter().__first_constructed = true;
-    __h.get_deleter().__second_constructed = true;
-    return __h;
-}
-
-template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder
-unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node_with_key(key_type&& __k)
-{
-    __node_allocator& __na = __table_.__node_alloc();
-    __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
-    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__cc.first), _VSTD::move(__k));
-    __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__cc.second));
-    __h.get_deleter().__second_constructed = true;
-    return __h;
-}
-
-#ifndef _LIBCPP_HAS_NO_VARIADICS
-
-template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-template <class _A0, class _A1, class ..._Args>
-typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder
-unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(_A0&& __a0,
-                                                                 _A1&& __a1,
-                                                                 _Args&&... __args)
-{
-    __node_allocator& __na = __table_.__node_alloc();
-    __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
-    __node_traits::construct(__na, _VSTD::addressof(__h->__value_),
-                             _VSTD::forward<_A0>(__a0), _VSTD::forward<_A1>(__a1),
-                             _VSTD::forward<_Args>(__args)...);
-    __h.get_deleter().__first_constructed = true;
-    __h.get_deleter().__second_constructed = true;
-    return __h;
-}
-
-template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-template <class... _Args>
-pair<typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::iterator, bool>
-unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::emplace(_Args&&... __args)
-{
-    __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
-    pair<iterator, bool> __r = __table_.__node_insert_unique(__h.get());
-    if (__r.second)
-        __h.release();
-    return __r;
-}
-
-#endif  // _LIBCPP_HAS_NO_VARIADICS
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
+#ifdef _LIBCPP_CXX03_LANG
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder
 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node_with_key(const key_type& __k)
@@ -1501,10 +1387,11 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node_with_key(const
     __h.get_deleter().__second_constructed = true;
     return _LIBCPP_EXPLICIT_MOVE(__h);  // explicitly moved for C++03
 }
+#endif
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 template <class _InputIterator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
                                                        _InputIterator __last)
@@ -1513,6 +1400,7 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
         __table_.__insert_unique(*__first);
 }
 
+#ifdef _LIBCPP_CXX03_LANG
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 _Tp&
 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](const key_type& __k)
@@ -1525,23 +1413,27 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](const key_type& __k)
     __h.release();
     return __r.first->second;
 }
+#else
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+_Tp&
+unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](const key_type& __k)
+{
+    return __table_.__emplace_unique_key_args(__k,
+        std::piecewise_construct, std::forward_as_tuple(__k),
+                                  std::forward_as_tuple()).first->__cc.second;
+}
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 _Tp&
 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](key_type&& __k)
 {
-    iterator __i = find(__k);
-    if (__i != end())
-        return __i->second;
-    __node_holder __h = __construct_node_with_key(_VSTD::move(__k));
-    pair<iterator, bool> __r = __table_.__node_insert_unique(__h.get());
-    __h.release();
-    return __r.first->second;
+    return __table_.__emplace_unique_key_args(__k,
+        std::piecewise_construct, std::forward_as_tuple(std::move(__k)),
+                                  std::forward_as_tuple()).first->__cc.second;
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif  // !_LIBCPP_CXX03_MODE
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 _Tp&
@@ -1635,17 +1527,21 @@ private:
 
     __table __table_;
 
+    typedef typename __table::_NodeTypes                   _NodeTypes;
     typedef typename __table::__node_traits                __node_traits;
     typedef typename __table::__node_allocator             __node_allocator;
     typedef typename __table::__node                       __node;
     typedef __hash_map_node_destructor<__node_allocator>   _Dp;
     typedef unique_ptr<__node, _Dp>                         __node_holder;
     typedef allocator_traits<allocator_type>               __alloc_traits;
+    static_assert((is_same<typename __node_traits::size_type,
+                          typename __alloc_traits::size_type>::value),
+                 "Allocator uses different size_type for different types");
 public:
     typedef typename __alloc_traits::pointer         pointer;
     typedef typename __alloc_traits::const_pointer   const_pointer;
-    typedef typename __alloc_traits::size_type       size_type;
-    typedef typename __alloc_traits::difference_type difference_type;
+    typedef typename __table::size_type              size_type;
+    typedef typename __table::difference_type        difference_type;
 
     typedef __hash_map_iterator<typename __table::iterator>       iterator;
     typedef __hash_map_const_iterator<typename __table::const_iterator> const_iterator;
@@ -1676,10 +1572,12 @@ public:
                       size_type __n, const hasher& __hf,
                       const key_equal& __eql,
                       const allocator_type& __a);
+    _LIBCPP_INLINE_VISIBILITY
     explicit unordered_multimap(const allocator_type& __a);
     unordered_multimap(const unordered_multimap& __u);
     unordered_multimap(const unordered_multimap& __u, const allocator_type& __a);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     unordered_multimap(unordered_multimap&& __u)
         _NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
     unordered_multimap(unordered_multimap&& __u, const allocator_type& __a);
@@ -1721,7 +1619,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     unordered_multimap& operator=(const unordered_multimap& __u)
     {
-#if __cplusplus >= 201103L
+#ifndef _LIBCPP_CXX03_LANG
         __table_ = __u.__table_;
 #else
         if (this != &__u) {
@@ -1736,10 +1634,12 @@ public:
         return *this;
     }
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     unordered_multimap& operator=(unordered_multimap&& __u)
         _NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
 #endif
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+    _LIBCPP_INLINE_VISIBILITY
     unordered_multimap& operator=(initializer_list<value_type> __il);
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
@@ -1767,43 +1667,55 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     const_iterator cend()   const _NOEXCEPT {return __table_.end();}
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#ifndef _LIBCPP_HAS_NO_VARIADICS
-
-    template <class... _Args>
-        iterator emplace(_Args&&... __args);
-
-    template <class... _Args>
-        iterator emplace_hint(const_iterator __p, _Args&&... __args);
-#endif  // _LIBCPP_HAS_NO_VARIADICS
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     iterator insert(const value_type& __x) {return __table_.__insert_multi(__x);}
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    template <class _Pp,
-              class = typename enable_if<is_constructible<value_type, _Pp>::value>::type>
-        _LIBCPP_INLINE_VISIBILITY
-        iterator insert(_Pp&& __x)
-            {return __table_.__insert_multi(_VSTD::forward<_Pp>(__x));}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+
     _LIBCPP_INLINE_VISIBILITY
     iterator insert(const_iterator __p, const value_type& __x)
         {return __table_.__insert_multi(__p.__i_, __x);}
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    template <class _Pp,
-              class = typename enable_if<is_constructible<value_type, _Pp>::value>::type>
-        _LIBCPP_INLINE_VISIBILITY
-        iterator insert(const_iterator __p, _Pp&& __x)
-            {return __table_.__insert_multi(__p.__i_, _VSTD::forward<_Pp>(__x));}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+
     template <class _InputIterator>
-        void insert(_InputIterator __first, _InputIterator __last);
+    _LIBCPP_INLINE_VISIBILITY
+    void insert(_InputIterator __first, _InputIterator __last);
+
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     _LIBCPP_INLINE_VISIBILITY
     void insert(initializer_list<value_type> __il)
         {insert(__il.begin(), __il.end());}
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
+#ifndef _LIBCPP_CXX03_LANG
+    _LIBCPP_INLINE_VISIBILITY
+    iterator insert(value_type&& __x) {return __table_.__insert_multi(_VSTD::move(__x));}
+
+    _LIBCPP_INLINE_VISIBILITY
+    iterator insert(const_iterator __p, value_type&& __x)
+        {return __table_.__insert_multi(__p.__i_, _VSTD::move(__x));}
+
+    template <class _Pp,
+              class = typename enable_if<is_constructible<value_type, _Pp>::value>::type>
+    _LIBCPP_INLINE_VISIBILITY
+    iterator insert(_Pp&& __x)
+        {return __table_.__insert_multi(_VSTD::forward<_Pp>(__x));}
+
+    template <class _Pp,
+              class = typename enable_if<is_constructible<value_type, _Pp>::value>::type>
+    _LIBCPP_INLINE_VISIBILITY
+    iterator insert(const_iterator __p, _Pp&& __x)
+        {return __table_.__insert_multi(__p.__i_, _VSTD::forward<_Pp>(__x));}
+
+    template <class... _Args>
+    iterator emplace(_Args&&... __args) {
+        return __table_.__emplace_multi(_VSTD::forward<_Args>(__args)...);
+    }
+
+    template <class... _Args>
+    iterator emplace_hint(const_iterator __p, _Args&&... __args) {
+        return __table_.__emplace_hint_multi(__p.__i_, _VSTD::forward<_Args>(__args)...);
+    }
+#endif  // _LIBCPP_CXX03_LANG
+
+
     _LIBCPP_INLINE_VISIBILITY
     iterator erase(const_iterator __p) {return __table_.erase(__p.__i_);}
     _LIBCPP_INLINE_VISIBILITY
@@ -1890,17 +1802,7 @@ public:
 
 #endif  // _LIBCPP_DEBUG_LEVEL >= 2
 
-private:
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    __node_holder __construct_node();
-    template <class _A0>
-        __node_holder
-         __construct_node(_A0&& __a0);
-#ifndef _LIBCPP_HAS_NO_VARIADICS
-    template <class _A0, class _A1, class ..._Args>
-        __node_holder __construct_node(_A0&& __a0, _A1&& __a1, _Args&& ...__args);
-#endif  // _LIBCPP_HAS_NO_VARIADICS
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+
 };
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
@@ -1966,7 +1868,7 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
         const allocator_type& __a)
     : __table_(__a)
@@ -2003,7 +1905,7 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
         unordered_multimap&& __u)
     _NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
@@ -2029,7 +1931,7 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
         while (__u.size() != 0)
         {
             __table_.__insert_multi(
-                _VSTD::move(__u.__table_.remove((__i++).__i_)->__value_)
+                      _VSTD::move(__u.__table_.remove((__i++).__i_)->__value_.__nc)
                                    );
         }
     }
@@ -2084,7 +1986,7 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>&
 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(unordered_multimap&& __u)
     _NOEXCEPT_(is_nothrow_move_assignable<__table>::value)
@@ -2098,7 +2000,7 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(unordered_multima
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>&
 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(
         initializer_list<value_type> __il)
@@ -2109,81 +2011,11 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(
 
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
-template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-typename unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder
-unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node()
-{
-    __node_allocator& __na = __table_.__node_alloc();
-    __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
-    __node_traits::construct(__na, _VSTD::addressof(__h->__value_));
-    __h.get_deleter().__first_constructed = true;
-    __h.get_deleter().__second_constructed = true;
-    return __h;
-}
-
-template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-template <class _A0>
-typename unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder
-unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(_A0&& __a0)
-{
-    __node_allocator& __na = __table_.__node_alloc();
-    __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
-    __node_traits::construct(__na, _VSTD::addressof(__h->__value_),
-                             _VSTD::forward<_A0>(__a0));
-    __h.get_deleter().__first_constructed = true;
-    __h.get_deleter().__second_constructed = true;
-    return __h;
-}
-
-#ifndef _LIBCPP_HAS_NO_VARIADICS
-
-template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-template <class _A0, class _A1, class ..._Args>
-typename unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder
-unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(
-        _A0&& __a0, _A1&& __a1, _Args&&... __args)
-{
-    __node_allocator& __na = __table_.__node_alloc();
-    __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
-    __node_traits::construct(__na, _VSTD::addressof(__h->__value_),
-                             _VSTD::forward<_A0>(__a0), _VSTD::forward<_A1>(__a1),
-                             _VSTD::forward<_Args>(__args)...);
-    __h.get_deleter().__first_constructed = true;
-    __h.get_deleter().__second_constructed = true;
-    return __h;
-}
-
-template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-template <class... _Args>
-typename unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::iterator
-unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::emplace(_Args&&... __args)
-{
-    __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
-    iterator __r = __table_.__node_insert_multi(__h.get());
-    __h.release();
-    return __r;
-}
-
-template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-template <class... _Args>
-typename unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::iterator
-unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::emplace_hint(
-        const_iterator __p, _Args&&... __args)
-{
-    __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
-    iterator __r = __table_.__node_insert_multi(__p.__i_, __h.get());
-    __h.release();
-    return __r;
-}
 
-#endif  // _LIBCPP_HAS_NO_VARIADICS
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 template <class _InputIterator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
                                                             _InputIterator __last)
diff --git a/include/unordered_set b/include/unordered_set
index f6ccdc3734f2..fb38b648a86a 100644
--- a/include/unordered_set
+++ b/include/unordered_set
@@ -404,10 +404,12 @@ public:
                       size_type __n, const hasher& __hf, const allocator_type& __a)
             : unordered_set(__first, __last, __n, __hf, key_equal(), __a) {}
 #endif
+    _LIBCPP_INLINE_VISIBILITY
     explicit unordered_set(const allocator_type& __a);
     unordered_set(const unordered_set& __u);
     unordered_set(const unordered_set& __u, const allocator_type& __a);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     unordered_set(unordered_set&& __u)
         _NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
     unordered_set(unordered_set&& __u, const allocator_type& __a);
@@ -439,10 +441,12 @@ public:
         return *this;
     }
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     unordered_set& operator=(unordered_set&& __u)
         _NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
 #endif
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+    _LIBCPP_INLINE_VISIBILITY
     unordered_set& operator=(initializer_list<value_type> __il);
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
@@ -527,6 +531,7 @@ public:
 #endif
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template <class _InputIterator>
+        _LIBCPP_INLINE_VISIBILITY
         void insert(_InputIterator __first, _InputIterator __last);
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     _LIBCPP_INLINE_VISIBILITY
@@ -678,7 +683,7 @@ unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
 }
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
         const allocator_type& __a)
     : __table_(__a)
@@ -715,7 +720,7 @@ unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
         unordered_set&& __u)
     _NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
@@ -792,7 +797,7 @@ unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 unordered_set<_Value, _Hash, _Pred, _Alloc>&
 unordered_set<_Value, _Hash, _Pred, _Alloc>::operator=(unordered_set&& __u)
     _NOEXCEPT_(is_nothrow_move_assignable<__table>::value)
@@ -806,7 +811,7 @@ unordered_set<_Value, _Hash, _Pred, _Alloc>::operator=(unordered_set&& __u)
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 unordered_set<_Value, _Hash, _Pred, _Alloc>&
 unordered_set<_Value, _Hash, _Pred, _Alloc>::operator=(
         initializer_list<value_type> __il)
@@ -819,7 +824,7 @@ unordered_set<_Value, _Hash, _Pred, _Alloc>::operator=(
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 template <class _InputIterator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 unordered_set<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
                                                     _InputIterator __last)
@@ -940,10 +945,12 @@ public:
                        size_type __n, const hasher& __hf, const allocator_type& __a)
         : unordered_multiset(__first, __last, __n, __hf, key_equal(), __a) {}
 #endif
+    _LIBCPP_INLINE_VISIBILITY
     explicit unordered_multiset(const allocator_type& __a);
     unordered_multiset(const unordered_multiset& __u);
     unordered_multiset(const unordered_multiset& __u, const allocator_type& __a);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     unordered_multiset(unordered_multiset&& __u)
         _NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
     unordered_multiset(unordered_multiset&& __u, const allocator_type& __a);
@@ -973,6 +980,7 @@ public:
         return *this;
     }
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     unordered_multiset& operator=(unordered_multiset&& __u)
         _NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
 #endif
@@ -1029,6 +1037,7 @@ public:
         {return __table_.__insert_multi(__p, _VSTD::move(__x));}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template <class _InputIterator>
+        _LIBCPP_INLINE_VISIBILITY
         void insert(_InputIterator __first, _InputIterator __last);
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     _LIBCPP_INLINE_VISIBILITY
@@ -1181,7 +1190,7 @@ unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
 }
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
         const allocator_type& __a)
     : __table_(__a)
@@ -1218,7 +1227,7 @@ unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
         unordered_multiset&& __u)
     _NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
@@ -1295,7 +1304,7 @@ unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 unordered_multiset<_Value, _Hash, _Pred, _Alloc>&
 unordered_multiset<_Value, _Hash, _Pred, _Alloc>::operator=(
         unordered_multiset&& __u)
@@ -1323,7 +1332,7 @@ unordered_multiset<_Value, _Hash, _Pred, _Alloc>::operator=(
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 template <class _InputIterator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 unordered_multiset<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
                                                          _InputIterator __last)
diff --git a/include/utility b/include/utility
index c9f5785b3d4e..7b978ad30969 100644
--- a/include/utility
+++ b/include/utility
@@ -82,8 +82,8 @@ struct pair
                                        is_nothrow_move_assignable<T2>::value);
     template <class U, class V> pair& operator=(pair<U, V>&& p);
 
-    void swap(pair& p) noexcept(noexcept(swap(first, p.first)) &&
-                                noexcept(swap(second, p.second)));
+    void swap(pair& p) noexcept(is_nothrow_swappable_v<T1> &&
+                                is_nothrow_swappable_v<T2>);
 };
 
 template <class T1, class T2> bool operator==(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14
@@ -169,7 +169,7 @@ template<size_t N>
 template<class... T>
   using index_sequence_for = make_index_sequence<sizeof...(T)>;
 
-template<class T, class U=T> 
+template<class T, class U=T>
     T exchange(T& obj, U&& new_value);
 }  // std
 
@@ -178,6 +178,7 @@ template<class T, class U=T>
 #include <__config>
 #include <__tuple>
 #include <type_traits>
+#include <initializer_list>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
@@ -224,10 +225,6 @@ operator>=(const _Tp& __x, const _Tp& __y)
 
 // swap_ranges
 
-// forward
-template<class _Tp, size_t _Np>
-inline _LIBCPP_INLINE_VISIBILITY
-void swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np]) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value);
 
 template <class _ForwardIterator1, class _ForwardIterator2>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -239,9 +236,12 @@ swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardItera
     return __first2;
 }
 
+// forward declared in <type_traits>
 template<class _Tp, size_t _Np>
 inline _LIBCPP_INLINE_VISIBILITY
-void
+typename enable_if<
+    __is_swappable<_Tp>::value
+>::type
 swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np]) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
 {
     _VSTD::swap_ranges(__a, __a + _Np, __b);
@@ -285,9 +285,6 @@ struct _LIBCPP_TYPE_VIS_ONLY pair
     _T1 first;
     _T2 second;
 
-    // pair(const pair&) = default;
-    // pair(pair&&) = default;
-
 #ifndef _LIBCPP_HAS_NO_DEFAULT_FUNCTION_TEMPLATE_ARGS
     template <bool _Dummy = true, class = typename enable_if<
         __dependent_type<is_default_constructible<_T1>, _Dummy>::value &&
@@ -310,10 +307,7 @@ struct _LIBCPP_TYPE_VIS_ONLY pair
                                       )
             : first(__p.first), second(__p.second) {}
 
-#if !defined(_LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS) && _LIBCPP_TRIVIAL_PAIR_COPY_CTOR
-    _LIBCPP_INLINE_VISIBILITY
-    pair(const pair& __p) = default;
-#elif !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) || !_LIBCPP_TRIVIAL_PAIR_COPY_CTOR
+#if defined(_LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR)
     _LIBCPP_INLINE_VISIBILITY
     pair(const pair& __p)
         _NOEXCEPT_(is_nothrow_copy_constructible<first_type>::value &&
@@ -322,6 +316,21 @@ struct _LIBCPP_TYPE_VIS_ONLY pair
           second(__p.second)
     {
     }
+
+# ifndef _LIBCPP_CXX03_LANG
+    _LIBCPP_INLINE_VISIBILITY
+    pair(pair&& __p) _NOEXCEPT_(is_nothrow_move_constructible<first_type>::value &&
+                                is_nothrow_move_constructible<second_type>::value)
+        : first(_VSTD::forward<first_type>(__p.first)),
+          second(_VSTD::forward<second_type>(__p.second))
+    {
+    }
+# endif
+#elif !defined(_LIBCPP_CXX03_LANG)
+    pair(pair const&) = default;
+    pair(pair&&) = default;
+#else
+  // Use the implicitly declared copy constructor in C++03
 #endif
 
     _LIBCPP_INLINE_VISIBILITY
@@ -353,19 +362,6 @@ struct _LIBCPP_TYPE_VIS_ONLY pair
             : first(_VSTD::forward<_U1>(__p.first)),
               second(_VSTD::forward<_U2>(__p.second)) {}
 
-#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
-    _LIBCPP_INLINE_VISIBILITY
-    pair(pair&& __p) = default;
-#else
-    _LIBCPP_INLINE_VISIBILITY
-    pair(pair&& __p) _NOEXCEPT_(is_nothrow_move_constructible<first_type>::value &&
-                                is_nothrow_move_constructible<second_type>::value)
-        : first(_VSTD::forward<first_type>(__p.first)),
-          second(_VSTD::forward<second_type>(__p.second))
-    {
-    }
-#endif
-
     _LIBCPP_INLINE_VISIBILITY
     pair&
     operator=(pair&& __p) _NOEXCEPT_(is_nothrow_move_assignable<first_type>::value &&
@@ -501,7 +497,6 @@ swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
-template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY reference_wrapper;
 
 template <class _Tp>
 struct __make_pair_return_impl
@@ -742,63 +737,15 @@ template<size_t... _Ip>
 #if __has_builtin(__make_integer_seq) && !defined(_LIBCPP_TESTING_FALLBACK_MAKE_INTEGER_SEQUENCE)
 
 template <class _Tp, _Tp _Ep>
-struct __make_integer_sequence
-{
-    typedef __make_integer_seq<integer_sequence, _Tp, _Ep> type;
-};
+using __make_integer_sequence = __make_integer_seq<integer_sequence, _Tp, _Ep>;
 
 #else
 
-namespace __detail {
-
-template<typename _Tp, size_t ..._Extra> struct __repeat;
-template<typename _Tp, _Tp ..._Np, size_t ..._Extra> struct __repeat<integer_sequence<_Tp, _Np...>, _Extra...> {
-  typedef integer_sequence<_Tp,
-                           _Np...,
-                           sizeof...(_Np) + _Np...,
-                           2 * sizeof...(_Np) + _Np...,
-                           3 * sizeof...(_Np) + _Np...,
-                           4 * sizeof...(_Np) + _Np...,
-                           5 * sizeof...(_Np) + _Np...,
-                           6 * sizeof...(_Np) + _Np...,
-                           7 * sizeof...(_Np) + _Np...,
-                           _Extra...> type;
-};
-
-template<size_t _Np> struct __parity;
-template<size_t _Np> struct __make : __parity<_Np % 8>::template __pmake<_Np> {};
-
-template<> struct __make<0> { typedef integer_sequence<size_t> type; };
-template<> struct __make<1> { typedef integer_sequence<size_t, 0> type; };
-template<> struct __make<2> { typedef integer_sequence<size_t, 0, 1> type; };
-template<> struct __make<3> { typedef integer_sequence<size_t, 0, 1, 2> type; };
-template<> struct __make<4> { typedef integer_sequence<size_t, 0, 1, 2, 3> type; };
-template<> struct __make<5> { typedef integer_sequence<size_t, 0, 1, 2, 3, 4> type; };
-template<> struct __make<6> { typedef integer_sequence<size_t, 0, 1, 2, 3, 4, 5> type; };
-template<> struct __make<7> { typedef integer_sequence<size_t, 0, 1, 2, 3, 4, 5, 6> type; };
-
-template<> struct __parity<0> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type> {}; };
-template<> struct __parity<1> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 1> {}; };
-template<> struct __parity<2> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 2, _Np - 1> {}; };
-template<> struct __parity<3> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 3, _Np - 2, _Np - 1> {}; };
-template<> struct __parity<4> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
-template<> struct __parity<5> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
-template<> struct __parity<6> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 6, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
-template<> struct __parity<7> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 7, _Np - 6, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
-
-template<typename _Tp, typename _Up> struct __convert {
-  template<typename> struct __result;
-  template<_Tp ..._Np> struct __result<integer_sequence<_Tp, _Np...> > { typedef integer_sequence<_Up, _Np...> type; };
-};
-template<typename _Tp> struct __convert<_Tp, _Tp> { template<typename _Up> struct __result { typedef _Up type; }; };
-
-}
-
 template<typename _Tp, _Tp _Np> using __make_integer_sequence_unchecked =
-  typename __detail::__convert<size_t, _Tp>::template __result<typename __detail::__make<_Np>::type>::type;
+  typename __detail::__make<_Np>::type::template __convert<integer_sequence, _Tp>;
 
 template <class _Tp, _Tp _Ep>
-struct __make_integer_sequence
+struct __make_integer_sequence_checked
 {
     static_assert(is_integral<_Tp>::value,
                   "std::make_integer_sequence can only be instantiated with an integral type" );
@@ -808,17 +755,20 @@ struct __make_integer_sequence
     typedef __make_integer_sequence_unchecked<_Tp, 0 <= _Ep ? _Ep : 0> type;
 };
 
+template <class _Tp, _Tp _Ep>
+using __make_integer_sequence = typename __make_integer_sequence_checked<_Tp, _Ep>::type;
+
 #endif
 
 template<class _Tp, _Tp _Np>
-    using make_integer_sequence = typename __make_integer_sequence<_Tp, _Np>::type;
+    using make_integer_sequence = __make_integer_sequence<_Tp, _Np>;
 
 template<size_t _Np>
     using make_index_sequence = make_integer_sequence<size_t, _Np>;
 
 template<class... _Tp>
     using index_sequence_for = make_index_sequence<sizeof...(_Tp)>;
-  
+
 #endif  // _LIBCPP_STD_VER > 11
 
 #if _LIBCPP_STD_VER > 11
@@ -829,7 +779,7 @@ _T1 exchange(_T1& __obj, _T2 && __new_value)
     _T1 __old_value = _VSTD::move(__obj);
     __obj = _VSTD::forward<_T2>(__new_value);
     return __old_value;
-}    
+}
 #endif  // _LIBCPP_STD_VER > 11
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/include/vector b/include/vector
index dbc0dd321824..021bbfb6643e 100644
--- a/include/vector
+++ b/include/vector
@@ -262,6 +262,7 @@ void swap(vector<T,Allocator>& x, vector<T,Allocator>& y)
 */
 
 #include <__config>
+#include <iosfwd> // for forward declaration of vector
 #include <__bit_reference>
 #include <type_traits>
 #include <climits>
@@ -453,7 +454,7 @@ __vector_base<_Tp, _Allocator>::~__vector_base()
     }
 }
 
-template <class _Tp, class _Allocator = allocator<_Tp> >
+template <class _Tp, class _Allocator /* = allocator<_Tp> */>
 class _LIBCPP_TYPE_VIS_ONLY vector
     : private __vector_base<_Tp, _Allocator>
 {
@@ -1811,9 +1812,9 @@ vector<_Tp, _Allocator>::emplace(const_iterator __position, _Args&&... __args)
         }
         else
         {
-            value_type __tmp(_VSTD::forward<_Args>(__args)...);
+            __temp_value<value_type, _Allocator> __tmp(this->__alloc(), _VSTD::forward<_Args>(__args)...);
             __move_range(__p, this->__end_, __p + 1);
-            *__p = _VSTD::move(__tmp);
+            *__p = _VSTD::move(__tmp.get());
         }
         __annotator.__done();
     }
@@ -2362,6 +2363,7 @@ public:
         _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || 
                     __is_nothrow_swappable<allocator_type>::value);
 #endif
+    static void swap(reference __x, reference __y) _NOEXCEPT { _VSTD::swap(__x, __y); }
 
     void resize(size_type __sz, value_type __x = false);
     void flip() _NOEXCEPT;
diff --git a/include/wchar.h b/include/wchar.h
index da34f735edf3..c0c6ef754fbe 100644
--- a/include/wchar.h
+++ b/include/wchar.h
@@ -118,7 +118,7 @@ size_t wcsrtombs(char* restrict dst, const wchar_t** restrict src, size_t len,
 
 #include_next <wchar.h>
 
-// Let <cwchar> know if we have const-correct overloads for wcschr and friends.
+// Determine whether we have const-correct overloads for wcschr and friends.
 #if defined(_WCHAR_H_CPLUSPLUS_98_CONFORMANCE_)
 #  define _LIBCPP_WCHAR_H_HAS_CONST_OVERLOADS 1
 #elif defined(__GLIBC_PREREQ)
@@ -127,6 +127,45 @@ size_t wcsrtombs(char* restrict dst, const wchar_t** restrict src, size_t len,
 #  endif
 #endif
 
+#if defined(__cplusplus) && !defined(_LIBCPP_WCHAR_H_HAS_CONST_OVERLOADS) && defined(_LIBCPP_PREFERRED_OVERLOAD)
+extern "C++" {
+inline _LIBCPP_INLINE_VISIBILITY
+wchar_t* __libcpp_wcschr(const wchar_t* __s, wchar_t __c) {return (wchar_t*)wcschr(__s, __c);}
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
+const wchar_t* wcschr(const wchar_t* __s, wchar_t __c) {return __libcpp_wcschr(__s, __c);}
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
+      wchar_t* wcschr(      wchar_t* __s, wchar_t __c) {return __libcpp_wcschr(__s, __c);}
+
+inline _LIBCPP_INLINE_VISIBILITY
+wchar_t* __libcpp_wcspbrk(const wchar_t* __s1, const wchar_t* __s2) {return (wchar_t*)wcspbrk(__s1, __s2);}
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
+const wchar_t* wcspbrk(const wchar_t* __s1, const wchar_t* __s2) {return __libcpp_wcspbrk(__s1, __s2);}
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
+      wchar_t* wcspbrk(      wchar_t* __s1, const wchar_t* __s2) {return __libcpp_wcspbrk(__s1, __s2);}
+
+inline _LIBCPP_INLINE_VISIBILITY
+wchar_t* __libcpp_wcsrchr(const wchar_t* __s, wchar_t __c) {return (wchar_t*)wcsrchr(__s, __c);}
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
+const wchar_t* wcsrchr(const wchar_t* __s, wchar_t __c) {return __libcpp_wcsrchr(__s, __c);}
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
+      wchar_t* wcsrchr(      wchar_t* __s, wchar_t __c) {return __libcpp_wcsrchr(__s, __c);}
+
+inline _LIBCPP_INLINE_VISIBILITY
+wchar_t* __libcpp_wcsstr(const wchar_t* __s1, const wchar_t* __s2) {return (wchar_t*)wcsstr(__s1, __s2);}
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
+const wchar_t* wcsstr(const wchar_t* __s1, const wchar_t* __s2) {return __libcpp_wcsstr(__s1, __s2);}
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
+      wchar_t* wcsstr(      wchar_t* __s1, const wchar_t* __s2) {return __libcpp_wcsstr(__s1, __s2);}
+
+inline _LIBCPP_INLINE_VISIBILITY
+wchar_t* __libcpp_wmemchr(const wchar_t* __s, wchar_t __c, size_t __n) {return (wchar_t*)wmemchr(__s, __c, __n);}
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
+const wchar_t* wmemchr(const wchar_t* __s, wchar_t __c, size_t __n) {return __libcpp_wmemchr(__s, __c, __n);}
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
+      wchar_t* wmemchr(      wchar_t* __s, wchar_t __c, size_t __n) {return __libcpp_wmemchr(__s, __c, __n);}
+}
+#endif
+
 #if defined(__cplusplus) && (defined(_LIBCPP_MSVCRT) || defined(__MINGW32__))
 extern "C++" {
 #include <support/win32/support.h> // pull in *swprintf defines
diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
index d6a35f8eba2e..afc388e7613f 100644
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -79,6 +79,7 @@ add_library_flags_if(LIBCXX_HAS_C_LIB c)
 add_library_flags_if(LIBCXX_HAS_M_LIB m)
 add_library_flags_if(LIBCXX_HAS_RT_LIB rt)
 add_library_flags_if(LIBCXX_HAS_GCC_S_LIB gcc_s)
+add_library_flags_if(LIBCXX_HAVE_CXX_ATOMICS_WITH_LIB atomic)
 
 # Setup flags.
 add_flags_if_supported(-fPIC)
@@ -87,7 +88,21 @@ add_link_flags_if_supported(-nodefaultlibs)
 if ( APPLE AND (LIBCXX_CXX_ABI_LIBNAME STREQUAL "libcxxabi" OR
                 LIBCXX_CXX_ABI_LIBNAME STREQUAL "none"))
   if (NOT DEFINED LIBCXX_LIBCPPABI_VERSION)
-    set(LIBCXX_LIBCPPABI_VERSION "2")
+    set(LIBCXX_LIBCPPABI_VERSION "2") # Default value
+    execute_process(
+      COMMAND xcrun --show-sdk-version
+      OUTPUT_VARIABLE sdk_ver
+      RESULT_VARIABLE res
+      OUTPUT_STRIP_TRAILING_WHITESPACE)
+    if (res EQUAL 0)
+      message(STATUS "Found SDK version ${sdk_ver}")
+      string(REPLACE "10." "" sdk_ver "${sdk_ver}")
+      if (sdk_ver LESS 9)
+        set(LIBCXX_LIBCPPABI_VERSION "")
+      else()
+        set(LIBCXX_LIBCPPABI_VERSION "2")
+      endif()
+    endif()
   endif()
 
   if ( CMAKE_OSX_DEPLOYMENT_TARGET STREQUAL "10.6" )
@@ -137,6 +152,26 @@ set_target_properties(cxx
     SOVERSION     "${LIBCXX_ABI_VERSION}"
   )
 
+if (LIBCXX_ENABLE_EXPERIMENTAL_LIBRARY)
+  file(GLOB LIBCXX_EXPERIMENTAL_SOURCES ../src/experimental/*.cpp)
+  if (LIBCXX_ENABLE_FILESYSTEM)
+    file(GLOB LIBCXX_FILESYSTEM_SOURCES ../src/experimental/filesystem/*.cpp)
+  endif()
+  add_library(cxx_experimental STATIC ${LIBCXX_EXPERIMENTAL_SOURCES} ${LIBCXX_FILESYSTEM_SOURCES})
+  target_link_libraries(cxx_experimental cxx)
+
+  set(experimental_flags "${LIBCXX_COMPILE_FLAGS}")
+  check_flag_supported(-std=c++14)
+  if (NOT MSVC AND LIBCXX_SUPPORTS_STD_EQ_CXX14_FLAG)
+    string(REPLACE "-std=c++11" "-std=c++14" experimental_flags "${LIBCXX_COMPILE_FLAGS}")
+  endif()
+  set_target_properties(cxx_experimental
+    PROPERTIES
+      COMPILE_FLAGS "${experimental_flags}"
+      OUTPUT_NAME   "c++experimental"
+  )
+endif()
+
 # Generate a linker script inplace of a libc++.so symlink. Rerun this command
 # after cxx builds.
 if (LIBCXX_ENABLE_ABI_LINKER_SCRIPT)
@@ -159,7 +194,10 @@ if (LIBCXX_ENABLE_ABI_LINKER_SCRIPT)
 endif()
 
 if (LIBCXX_INSTALL_LIBRARY)
-  install(TARGETS cxx
+  if (LIBCXX_INSTALL_EXPERIMENTAL_LIBRARY)
+    set(experimental_lib cxx_experimental)
+  endif()
+  install(TARGETS cxx ${experimental_lib}
     LIBRARY DESTINATION lib${LIBCXX_LIBDIR_SUFFIX} COMPONENT libcxx
     ARCHIVE DESTINATION lib${LIBCXX_LIBDIR_SUFFIX} COMPONENT libcxx
     )
@@ -177,10 +215,18 @@ endif()
 if (NOT CMAKE_CONFIGURATION_TYPES AND (LIBCXX_INSTALL_LIBRARY OR
                                        LIBCXX_INSTALL_HEADERS))
     if(LIBCXX_INSTALL_LIBRARY)
-      set(deps DEPENDS cxx)
+      set(lib_install_target cxx)
+    endif()
+    if (LIBCXX_INSTALL_EXPERIMENTAL_LIBRARY)
+      set(experimental_lib_install_target cxx_experimental)
+    endif()
+    if(LIBCXX_INSTALL_HEADERS)
+      set(header_install_target install-libcxx-headers)
     endif()
     add_custom_target(install-libcxx
-                      ${deps}
+                      DEPENDS ${lib_install_target}
+                              ${experimental_lib_install_target}
+                              ${header_install_target}
                       COMMAND "${CMAKE_COMMAND}"
                       -DCMAKE_INSTALL_COMPONENT=libcxx
                       -P "${LIBCXX_BINARY_DIR}/cmake_install.cmake")
diff --git a/lib/buildit b/lib/buildit
index 7e3bc2ed2a96..6451a9bfad6c 100755
--- a/lib/buildit
+++ b/lib/buildit
@@ -41,7 +41,7 @@ then
 fi
 
 EXTRA_FLAGS="-nostdinc++ -std=${CXX_LANG} -fstrict-aliasing -Wall -Wextra -Wshadow -Wconversion \
-             -Wpadded -Wstrict-aliasing=2 -Wstrict-overflow=4 "
+             -Wstrict-aliasing=2 -Wstrict-overflow=4 "
 
 case $TRIPLE in
   *-apple-*)
diff --git a/src/algorithm.cpp b/src/algorithm.cpp
index e548856ff6e1..e9752b0653e0 100644
--- a/src/algorithm.cpp
+++ b/src/algorithm.cpp
@@ -48,14 +48,14 @@ template bool __insertion_sort_incomplete<__less<long double>&, long double*>(lo
 template unsigned __sort5<__less<long double>&, long double*>(long double*, long double*, long double*, long double*, long double*, __less<long double>&);
 
 #ifndef _LIBCPP_HAS_NO_THREADS
-static pthread_mutex_t __rs_mut = PTHREAD_MUTEX_INITIALIZER;
+static __libcpp_mutex_t __rs_mut = _LIBCPP_MUTEX_INITIALIZER;
 #endif
 unsigned __rs_default::__c_ = 0;
 
 __rs_default::__rs_default()
 {
 #ifndef _LIBCPP_HAS_NO_THREADS
-    pthread_mutex_lock(&__rs_mut);
+    __libcpp_mutex_lock(&__rs_mut);
 #endif
     __c_ = 1;
 }
@@ -69,7 +69,7 @@ __rs_default::~__rs_default()
 {
 #ifndef _LIBCPP_HAS_NO_THREADS
     if (--__c_ == 0)
-        pthread_mutex_unlock(&__rs_mut);
+       __libcpp_mutex_unlock(&__rs_mut);
 #else
     --__c_;
 #endif
diff --git a/src/bind.cpp b/src/bind.cpp
index cab0b7c03a91..b318fc16979e 100644
--- a/src/bind.cpp
+++ b/src/bind.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#define _LIBCPP_BUILDING_BIND
 #include "functional"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -14,16 +15,16 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace placeholders
 {
 
-__ph<1>   _1;
-__ph<2>   _2;
-__ph<3>   _3;
-__ph<4>   _4;
-__ph<5>   _5;
-__ph<6>   _6;
-__ph<7>   _7;
-__ph<8>   _8;
-__ph<9>   _9;
-__ph<10> _10;
+const __ph<1>   _1{};
+const __ph<2>   _2{};
+const __ph<3>   _3{};
+const __ph<4>   _4{};
+const __ph<5>   _5{};
+const __ph<6>   _6{};
+const __ph<7>   _7{};
+const __ph<8>   _8{};
+const __ph<9>   _9{};
+const __ph<10> _10{};
 
 }  // placeholders
 
diff --git a/src/condition_variable.cpp b/src/condition_variable.cpp
index 5fd5fc891c16..bfb4bf3925f7 100644
--- a/src/condition_variable.cpp
+++ b/src/condition_variable.cpp
@@ -20,19 +20,19 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 condition_variable::~condition_variable()
 {
-    pthread_cond_destroy(&__cv_);
+    __libcpp_condvar_destroy(&__cv_);
 }
 
 void
 condition_variable::notify_one() _NOEXCEPT
 {
-    pthread_cond_signal(&__cv_);
+    __libcpp_condvar_signal(&__cv_);
 }
 
 void
 condition_variable::notify_all() _NOEXCEPT
 {
-    pthread_cond_broadcast(&__cv_);
+    __libcpp_condvar_broadcast(&__cv_);
 }
 
 void
@@ -41,7 +41,7 @@ condition_variable::wait(unique_lock<mutex>& lk) _NOEXCEPT
     if (!lk.owns_lock())
         __throw_system_error(EPERM,
                                   "condition_variable::wait: mutex not locked");
-    int ec = pthread_cond_wait(&__cv_, lk.mutex()->native_handle());
+    int ec = __libcpp_condvar_wait(&__cv_, lk.mutex()->native_handle());
     if (ec)
         __throw_system_error(ec, "condition_variable wait failed");
 }
@@ -71,7 +71,7 @@ condition_variable::__do_timed_wait(unique_lock<mutex>& lk,
         ts.tv_sec = ts_sec_max;
         ts.tv_nsec = giga::num - 1;
     }
-    int ec = pthread_cond_timedwait(&__cv_, lk.mutex()->native_handle(), &ts);
+    int ec = __libcpp_condvar_timedwait(&__cv_, lk.mutex()->native_handle(), &ts);
     if (ec != 0 && ec != ETIMEDOUT)
         __throw_system_error(ec, "condition_variable timed_wait failed");
 }
diff --git a/src/experimental/filesystem/directory_iterator.cpp b/src/experimental/filesystem/directory_iterator.cpp
new file mode 100644
index 000000000000..fa217ba7a12c
--- /dev/null
+++ b/src/experimental/filesystem/directory_iterator.cpp
@@ -0,0 +1,256 @@
+#include "experimental/filesystem"
+#include <dirent.h>
+#include <errno.h>
+
+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM
+
+namespace { namespace detail {
+
+inline error_code capture_errno() {
+    _LIBCPP_ASSERT(errno, "Expected errno to be non-zero");
+    return error_code{errno, std::generic_category()};
+}
+
+template <class ...Args>
+inline bool capture_error_or_throw(std::error_code* user_ec,
+                                   const char* msg, Args&&... args)
+{
+    std::error_code my_ec = capture_errno();
+    if (user_ec) {
+        *user_ec = my_ec;
+        return true;
+    }
+    __libcpp_throw(filesystem_error(msg, std::forward<Args>(args)..., my_ec));
+    return false;
+}
+
+template <class ...Args>
+inline bool set_or_throw(std::error_code& my_ec,
+                               std::error_code* user_ec,
+                               const char* msg, Args&&... args)
+{
+    if (user_ec) {
+        *user_ec = my_ec;
+        return true;
+    }
+    __libcpp_throw(filesystem_error(msg, std::forward<Args>(args)..., my_ec));
+    return false;
+}
+
+typedef path::string_type string_type;
+
+
+inline string_type posix_readdir(DIR *dir_stream, error_code& ec) {
+    struct dirent* dir_entry_ptr = nullptr;
+    errno = 0; // zero errno in order to detect errors
+    if ((dir_entry_ptr = ::readdir(dir_stream)) == nullptr) {
+        ec = capture_errno();
+        return {};
+    } else {
+        ec.clear();
+        return dir_entry_ptr->d_name;
+    }
+}
+
+}}                                                       // namespace detail
+
+using detail::set_or_throw;
+
+class __dir_stream {
+public:
+    __dir_stream() = delete;
+    __dir_stream& operator=(const __dir_stream&) = delete;
+
+    __dir_stream(__dir_stream&& other) noexcept
+        : __stream_(other.__stream_), __root_(std::move(other.__root_)),
+          __entry_(std::move(other.__entry_))
+    {
+        other.__stream_ = nullptr;
+    }
+
+
+    __dir_stream(const path& root, directory_options opts, error_code& ec)
+        : __stream_(nullptr),
+          __root_(root)
+    {
+        if ((__stream_ = ::opendir(root.c_str())) == nullptr) {
+            ec = detail::capture_errno();
+            const bool allow_eacess =
+                bool(opts & directory_options::skip_permission_denied);
+            if (allow_eacess && ec.value() == EACCES)
+                ec.clear();
+            return;
+        }
+        advance(ec);
+    }
+
+    ~__dir_stream() noexcept
+      { if (__stream_) close(); }
+
+    bool good() const noexcept { return __stream_ != nullptr; }
+
+    bool advance(error_code &ec) {
+        while (true) {
+            auto str = detail::posix_readdir(__stream_,  ec);
+            if (str == "." || str == "..") {
+                continue;
+            } else if (ec || str.empty()) {
+                close();
+                return false;
+            } else {
+                __entry_.assign(__root_ / str);
+                return true;
+            }
+        }
+    }
+private:
+    std::error_code close() noexcept {
+        std::error_code m_ec;
+        if (::closedir(__stream_) == -1)
+           m_ec = detail::capture_errno();
+        __stream_ = nullptr;
+        return m_ec;
+    }
+
+    DIR * __stream_{nullptr};
+public:
+    path __root_;
+    directory_entry __entry_;
+};
+
+// directory_iterator
+
+directory_iterator::directory_iterator(const path& p, error_code *ec,
+                                       directory_options opts)
+{
+    std::error_code m_ec;
+    __imp_ = make_shared<__dir_stream>(p, opts, m_ec);
+    if (ec) *ec = m_ec;
+    if (!__imp_->good()) {
+        __imp_.reset();
+        if (m_ec)
+            set_or_throw(m_ec, ec,
+                         "directory_iterator::directory_iterator(...)", p);
+    }
+}
+
+directory_iterator& directory_iterator::__increment(error_code *ec)
+{
+    _LIBCPP_ASSERT(__imp_, "Attempting to increment an invalid iterator");
+    std::error_code m_ec;
+    if (!__imp_->advance(m_ec)) {
+        __imp_.reset();
+        if (m_ec)
+            set_or_throw(m_ec, ec, "directory_iterator::operator++()");
+    } else {
+        if (ec) ec->clear();
+    }
+    return *this;
+
+}
+
+directory_entry const& directory_iterator::__deref() const {
+    _LIBCPP_ASSERT(__imp_, "Attempting to dereference an invalid iterator");
+    return __imp_->__entry_;
+}
+
+// recursive_directory_iterator
+
+struct recursive_directory_iterator::__shared_imp {
+  stack<__dir_stream> __stack_;
+  directory_options   __options_;
+};
+
+recursive_directory_iterator::recursive_directory_iterator(const path& p,
+    directory_options opt, error_code *ec)
+    : __imp_(nullptr), __rec_(true)
+{
+    if (ec) ec->clear();
+    std::error_code m_ec;
+    __dir_stream new_s(p, opt, m_ec);
+    if (m_ec) set_or_throw(m_ec, ec, "recursive_directory_iterator", p);
+    if (m_ec || !new_s.good()) return;
+
+    __imp_ = _VSTD::make_shared<__shared_imp>();
+    __imp_->__options_ = opt;
+    __imp_->__stack_.push(_VSTD::move(new_s));
+}
+
+void recursive_directory_iterator::__pop(error_code* ec)
+{
+    _LIBCPP_ASSERT(__imp_, "Popping the end iterator");
+    if (ec) ec->clear();
+    __imp_->__stack_.pop();
+    if (__imp_->__stack_.size() == 0)
+        __imp_.reset();
+    else
+        __advance(ec);
+}
+
+directory_options recursive_directory_iterator::options() const {
+    return __imp_->__options_;
+}
+
+int recursive_directory_iterator::depth() const {
+    return __imp_->__stack_.size() - 1;
+}
+
+const directory_entry& recursive_directory_iterator::__deref() const {
+    return __imp_->__stack_.top().__entry_;
+}
+
+recursive_directory_iterator&
+recursive_directory_iterator::__increment(error_code *ec)
+{
+    if (ec) ec->clear();
+    if (recursion_pending()) {
+        if (__try_recursion(ec) || (ec && *ec))
+            return *this;
+    }
+    __rec_ = true;
+    __advance(ec);
+    return *this;
+}
+
+void recursive_directory_iterator::__advance(error_code* ec) {
+    // REQUIRES: ec must be cleared before calling this function.
+    const directory_iterator end_it;
+    auto& stack = __imp_->__stack_;
+    std::error_code m_ec;
+    while (stack.size() > 0) {
+        if (stack.top().advance(m_ec))
+            return;
+        if (m_ec) break;
+        stack.pop();
+    }
+    __imp_.reset();
+    if (m_ec)
+        set_or_throw(m_ec, ec, "recursive_directory_iterator::operator++()");
+}
+
+bool recursive_directory_iterator::__try_recursion(error_code *ec) {
+
+    bool rec_sym =
+        bool(options() & directory_options::follow_directory_symlink);
+    auto& curr_it = __imp_->__stack_.top();
+
+    if (is_directory(curr_it.__entry_.status()) &&
+        (!is_symlink(curr_it.__entry_.symlink_status()) || rec_sym))
+    {
+        std::error_code m_ec;
+        __dir_stream new_it(curr_it.__entry_.path(), __imp_->__options_, m_ec);
+        if (new_it.good()) {
+            __imp_->__stack_.push(_VSTD::move(new_it));
+            return true;
+        }
+        if (m_ec) {
+            __imp_.reset();
+            set_or_throw(m_ec, ec,
+                               "recursive_directory_iterator::operator++()");
+        }
+    }
+    return false;
+}
+
+
+_LIBCPP_END_NAMESPACE_EXPERIMENTAL_FILESYSTEM
diff --git a/src/experimental/filesystem/operations.cpp b/src/experimental/filesystem/operations.cpp
new file mode 100644
index 000000000000..369996fcbe62
--- /dev/null
+++ b/src/experimental/filesystem/operations.cpp
@@ -0,0 +1,794 @@
+//===--------------------- filesystem/ops.cpp -----------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+#include "experimental/filesystem"
+#include "iterator"
+#include "fstream"
+#include "type_traits"
+#include "random"  /* for unique_path */
+#include "cstdlib"
+#include "climits"
+
+#include <unistd.h>
+#include <sys/stat.h>
+#include <sys/statvfs.h>
+#include <fcntl.h>  /* values for fchmodat */
+#if !defined(UTIME_OMIT)
+#include <sys/time.h> // for ::utimes as used in __last_write_time
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM
+
+filesystem_error::~filesystem_error() {}
+
+
+//                       POSIX HELPERS
+
+namespace detail { namespace  {
+
+using value_type = path::value_type;
+using string_type = path::string_type;
+
+
+
+inline std::error_code capture_errno() {
+    _LIBCPP_ASSERT(errno, "Expected errno to be non-zero");
+    std::error_code m_ec(errno, std::generic_category());
+    return m_ec;
+}
+
+void set_or_throw(std::error_code const& m_ec, std::error_code* ec,
+                  const char* msg, path const& p = {}, path const& p2 = {})
+{
+    if (ec) {
+        *ec = m_ec;
+    } else {
+        string msg_s("std::experimental::filesystem::");
+        msg_s += msg;
+        __libcpp_throw(filesystem_error(msg_s, p, p2, m_ec));
+    }
+}
+
+void set_or_throw(std::error_code* ec, const char* msg,
+                  path const& p = {}, path const& p2 = {})
+{
+    return set_or_throw(capture_errno(), ec, msg, p, p2);
+}
+
+perms posix_get_perms(const struct ::stat & st) noexcept {
+    return static_cast<perms>(st.st_mode) & perms::mask;
+}
+
+::mode_t posix_convert_perms(perms prms) {
+    return static_cast< ::mode_t>(prms & perms::mask);
+}
+
+file_status create_file_status(std::error_code& m_ec, path const& p,
+                               struct ::stat& path_stat,
+                               std::error_code* ec)
+{
+    if (ec) *ec = m_ec;
+    if (m_ec && (m_ec.value() == ENOENT || m_ec.value() == ENOTDIR)) {
+        return file_status(file_type::not_found);
+    }
+    else if (m_ec) {
+        set_or_throw(m_ec, ec, "posix_stat", p);
+        return file_status(file_type::none);
+    }
+    // else
+
+    file_status fs_tmp;
+    auto const mode = path_stat.st_mode;
+    if      (S_ISLNK(mode))  fs_tmp.type(file_type::symlink);
+    else if (S_ISREG(mode))  fs_tmp.type(file_type::regular);
+    else if (S_ISDIR(mode))  fs_tmp.type(file_type::directory);
+    else if (S_ISBLK(mode))  fs_tmp.type(file_type::block);
+    else if (S_ISCHR(mode))  fs_tmp.type(file_type::character);
+    else if (S_ISFIFO(mode)) fs_tmp.type(file_type::fifo);
+    else if (S_ISSOCK(mode)) fs_tmp.type(file_type::socket);
+    else                     fs_tmp.type(file_type::unknown);
+
+    fs_tmp.permissions(detail::posix_get_perms(path_stat));
+    return fs_tmp;
+}
+
+file_status posix_stat(path const & p, struct ::stat& path_stat,
+                       std::error_code* ec)
+{
+    std::error_code m_ec;
+    if (::stat(p.c_str(), &path_stat) == -1)
+        m_ec = detail::capture_errno();
+    return create_file_status(m_ec, p, path_stat, ec);
+}
+
+file_status posix_stat(path const & p, std::error_code* ec) {
+    struct ::stat path_stat;
+    return posix_stat(p, path_stat, ec);
+}
+
+file_status posix_lstat(path const & p, struct ::stat & path_stat,
+                        std::error_code* ec)
+{
+    std::error_code m_ec;
+    if (::lstat(p.c_str(), &path_stat) == -1)
+        m_ec = detail::capture_errno();
+    return create_file_status(m_ec, p, path_stat, ec);
+}
+
+file_status posix_lstat(path const & p, std::error_code* ec) {
+    struct ::stat path_stat;
+    return posix_lstat(p, path_stat, ec);
+}
+
+bool stat_equivalent(struct ::stat& st1, struct ::stat& st2) {
+    return (st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino);
+}
+
+//                           DETAIL::MISC
+
+
+bool copy_file_impl(const path& from, const path& to, perms from_perms,
+                    std::error_code *ec)
+{
+    std::ifstream in(from.c_str(), std::ios::binary);
+    std::ofstream out(to.c_str(),  std::ios::binary);
+
+    if (in.good() && out.good()) {
+        using InIt = std::istreambuf_iterator<char>;
+        using OutIt = std::ostreambuf_iterator<char>;
+        InIt bin(in);
+        InIt ein;
+        OutIt bout(out);
+        std::copy(bin, ein, bout);
+    }
+    if (out.fail() || in.fail()) {
+        set_or_throw(make_error_code(errc::operation_not_permitted),
+                     ec, "copy_file", from, to);
+        return false;
+    }
+    __permissions(to, from_perms, ec);
+    // TODO what if permissions fails?
+    return true;
+}
+
+}} // end namespace detail
+
+using detail::set_or_throw;
+
+path __canonical(path const & orig_p, const path& base, std::error_code *ec)
+{
+    path p = absolute(orig_p, base);
+    char buff[PATH_MAX + 1];
+    char *ret;
+    if ((ret = ::realpath(p.c_str(), buff)) == nullptr) {
+        set_or_throw(ec, "canonical", orig_p, base);
+        return {};
+    }
+    if (ec) ec->clear();
+    return {ret};
+}
+
+void __copy(const path& from, const path& to, copy_options options,
+            std::error_code *ec)
+{
+    const bool sym_status = bool(options &
+        (copy_options::create_symlinks | copy_options::skip_symlinks));
+
+    const bool sym_status2 = bool(options &
+        copy_options::copy_symlinks);
+
+    std::error_code m_ec;
+    struct ::stat f_st = {};
+    const file_status f = sym_status || sym_status2
+                                     ? detail::posix_lstat(from, f_st, &m_ec)
+                                     : detail::posix_stat(from,  f_st, &m_ec);
+    if (m_ec)
+        return set_or_throw(m_ec, ec, "copy", from, to);
+
+    struct ::stat t_st = {};
+    const file_status t = sym_status ? detail::posix_lstat(to, t_st, &m_ec)
+                                     : detail::posix_stat(to, t_st, &m_ec);
+
+    if (not status_known(t))
+        return set_or_throw(m_ec, ec, "copy", from, to);
+
+    if (!exists(f) || is_other(f) || is_other(t)
+        || (is_directory(f) && is_regular_file(t))
+        || detail::stat_equivalent(f_st, t_st))
+    {
+        return set_or_throw(make_error_code(errc::function_not_supported),
+                            ec, "copy", from, to);
+    }
+
+    if (ec) ec->clear();
+
+    if (is_symlink(f)) {
+        if (bool(copy_options::skip_symlinks & options)) {
+            // do nothing
+        } else if (not exists(t)) {
+            __copy_symlink(from, to, ec);
+        } else {
+            set_or_throw(make_error_code(errc::file_exists),
+                         ec, "copy", from, to);
+        }
+        return;
+    }
+    else if (is_regular_file(f)) {
+        if (bool(copy_options::directories_only & options)) {
+            // do nothing
+        }
+        else if (bool(copy_options::create_symlinks & options)) {
+            __create_symlink(from, to, ec);
+        }
+        else if (bool(copy_options::create_hard_links & options)) {
+            __create_hard_link(from, to, ec);
+        }
+        else if (is_directory(t)) {
+            __copy_file(from, to / from.filename(), options, ec);
+        } else {
+            __copy_file(from, to, options, ec);
+        }
+        return;
+    }
+    else if (is_directory(f)) {
+        if (not bool(copy_options::recursive & options) &&
+            bool(copy_options::__in_recursive_copy & options))
+        {
+            return;
+        }
+
+        if (!exists(t)) {
+            // create directory to with attributes from 'from'.
+            __create_directory(to, from, ec);
+            if (ec && *ec) { return; }
+        }
+        directory_iterator it = ec ? directory_iterator(from, *ec)
+                                   : directory_iterator(from);
+        if (ec && *ec) { return; }
+        std::error_code m_ec;
+        for (; it != directory_iterator(); it.increment(m_ec)) {
+            if (m_ec) return set_or_throw(m_ec, ec, "copy", from, to);
+            __copy(it->path(), to / it->path().filename(),
+                   options | copy_options::__in_recursive_copy, ec);
+            if (ec && *ec) { return; }
+        }
+    }
+}
+
+
+bool __copy_file(const path& from, const path& to, copy_options options,
+                 std::error_code *ec)
+{
+    if (ec) ec->clear();
+
+    std::error_code m_ec;
+    auto from_st = detail::posix_stat(from, &m_ec);
+    if (not is_regular_file(from_st)) {
+        if (not m_ec)
+            m_ec = make_error_code(errc::not_supported);
+        set_or_throw(m_ec, ec, "copy_file", from, to);
+        return false;
+    }
+
+    auto to_st = detail::posix_stat(to, &m_ec);
+    if (!status_known(to_st)) {
+        set_or_throw(m_ec, ec, "copy_file", from, to);
+        return false;
+    }
+
+    const bool to_exists = exists(to_st);
+    if (to_exists && bool(copy_options::skip_existing & options)) {
+        return false;
+    }
+    else if (to_exists && bool(copy_options::update_existing & options)) {
+        auto from_time = __last_write_time(from, ec);
+        if (ec && *ec) { return false; }
+        auto to_time = __last_write_time(to, ec);
+        if (ec && *ec) { return false; }
+        if (from_time <= to_time) {
+            return false;
+        }
+        return detail::copy_file_impl(from, to, from_st.permissions(), ec);
+    }
+    else if (!to_exists || bool(copy_options::overwrite_existing & options)) {
+        return detail::copy_file_impl(from, to, from_st.permissions(), ec);
+    }
+    else {
+        set_or_throw(make_error_code(errc::file_exists), ec, "copy", from, to);
+        return false;
+    }
+}
+
+void __copy_symlink(const path& existing_symlink, const path& new_symlink,
+                    std::error_code *ec)
+{
+    const path real_path(__read_symlink(existing_symlink, ec));
+    if (ec && *ec) { return; }
+    // NOTE: proposal says you should detect if you should call
+    // create_symlink or create_directory_symlink. I don't think this
+    // is needed with POSIX
+    __create_symlink(real_path, new_symlink, ec);
+}
+
+
+bool __create_directories(const path& p, std::error_code *ec)
+{
+    std::error_code m_ec;
+    auto const st = detail::posix_stat(p, &m_ec);
+    if (!status_known(st)) {
+        set_or_throw(m_ec, ec, "create_directories", p);
+        return false;
+    }
+    else if (is_directory(st)) {
+        if (ec) ec->clear();
+        return false;
+    }
+    else if (exists(st)) {
+        set_or_throw(make_error_code(errc::file_exists),
+                     ec, "create_directories", p);
+        return false;
+    }
+
+    const path parent = p.parent_path();
+    if (!parent.empty()) {
+        const file_status parent_st = status(parent, m_ec);
+        if (not status_known(parent_st)) {
+            set_or_throw(m_ec, ec, "create_directories", p);
+            return false;
+        }
+        if (not exists(parent_st)) {
+            __create_directories(parent, ec);
+            if (ec && *ec) { return false; }
+        }
+    }
+    return __create_directory(p, ec);
+}
+
+bool __create_directory(const path& p, std::error_code *ec)
+{
+    if (ec) ec->clear();
+    if (::mkdir(p.c_str(), static_cast<int>(perms::all)) == 0)
+        return true;
+    if (errno != EEXIST || !is_directory(p))
+        set_or_throw(ec, "create_directory", p);
+    return false;
+}
+
+bool __create_directory(path const & p, path const & attributes,
+                        std::error_code *ec)
+{
+    struct ::stat attr_stat;
+    std::error_code mec;
+    auto st = detail::posix_stat(attributes, attr_stat, &mec);
+    if (!status_known(st)) {
+        set_or_throw(mec, ec, "create_directory", p, attributes);
+        return false;
+    }
+    if (ec) ec->clear();
+    if (::mkdir(p.c_str(), attr_stat.st_mode) == 0)
+        return true;
+    if (errno != EEXIST || !is_directory(p))
+        set_or_throw(ec, "create_directory", p, attributes);
+    return false;
+}
+
+void __create_directory_symlink(path const & from, path const & to,
+                                std::error_code *ec){
+    if (::symlink(from.c_str(), to.c_str()) != 0)
+        set_or_throw(ec, "create_directory_symlink", from, to);
+    else if (ec)
+        ec->clear();
+}
+
+void __create_hard_link(const path& from, const path& to, std::error_code *ec){
+    if (::link(from.c_str(), to.c_str()) == -1)
+        set_or_throw(ec, "create_hard_link", from, to);
+    else if (ec)
+        ec->clear();
+}
+
+void __create_symlink(path const & from, path const & to, std::error_code *ec) {
+
+    if (::symlink(from.c_str(), to.c_str()) == -1)
+        set_or_throw(ec, "create_symlink", from, to);
+    else if (ec)
+        ec->clear();
+}
+
+path __current_path(std::error_code *ec) {
+    auto size = ::pathconf(".", _PC_PATH_MAX);
+    _LIBCPP_ASSERT(size >= 0, "pathconf returned a 0 as max size");
+
+    auto buff = std::unique_ptr<char[]>(new char[size + 1]);
+    char* ret;
+    if ((ret = ::getcwd(buff.get(), static_cast<size_t>(size))) == nullptr) {
+        set_or_throw(ec, "current_path");
+        return {};
+    }
+    if (ec) ec->clear();
+    return {buff.get()};
+}
+
+void __current_path(const path& p, std::error_code *ec) {
+    if (::chdir(p.c_str()) == -1)
+        set_or_throw(ec, "current_path", p);
+    else if (ec)
+        ec->clear();
+}
+
+bool __equivalent(const path& p1, const path& p2, std::error_code *ec)
+{
+    std::error_code ec1, ec2;
+    struct ::stat st1 = {};
+    struct ::stat st2 = {};
+    auto s1 = detail::posix_stat(p1.native(), st1, &ec1);
+    auto s2 = detail::posix_stat(p2.native(), st2, &ec2);
+
+    if ((!exists(s1) && !exists(s2)) || (is_other(s1) && is_other(s2))) {
+        set_or_throw(make_error_code(errc::not_supported), ec,
+                     "equivalent", p1, p2);
+        return false;
+    }
+    if (ec) ec->clear();
+    return (st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino);
+}
+
+
+std::uintmax_t __file_size(const path& p, std::error_code *ec)
+{
+    std::error_code m_ec;
+    struct ::stat st;
+    file_status fst = detail::posix_stat(p, st, &m_ec);
+    if (!exists(fst) || !is_regular_file(fst)) {
+        if (!m_ec)
+            m_ec = make_error_code(errc::not_supported);
+        set_or_throw(m_ec, ec, "file_size", p);
+        return static_cast<uintmax_t>(-1);
+    }
+    // is_regular_file(p) == true
+    if (ec) ec->clear();
+    return static_cast<std::uintmax_t>(st.st_size);
+}
+
+std::uintmax_t __hard_link_count(const path& p, std::error_code *ec)
+{
+    std::error_code m_ec;
+    struct ::stat st;
+    detail::posix_stat(p, st, &m_ec);
+    if (m_ec) {
+        set_or_throw(m_ec, ec, "hard_link_count", p);
+        return static_cast<std::uintmax_t>(-1);
+    }
+    if (ec) ec->clear();
+    return static_cast<std::uintmax_t>(st.st_nlink);
+}
+
+
+bool __fs_is_empty(const path& p, std::error_code *ec)
+{
+    if (ec) ec->clear();
+    std::error_code m_ec;
+    struct ::stat pst;
+    auto st = detail::posix_stat(p, pst, &m_ec);
+    if (is_directory(st))
+        return directory_iterator(p) == directory_iterator{};
+    else if (is_regular_file(st))
+        return static_cast<std::uintmax_t>(pst.st_size) == 0;
+    // else
+    set_or_throw(m_ec, ec, "is_empty", p);
+    return false;
+}
+
+
+namespace detail { namespace {
+
+template <class CType, class ChronoType>
+bool checked_set(CType* out, ChronoType time) {
+    using Lim = numeric_limits<CType>;
+    if (time > Lim::max() || time < Lim::min())
+        return false;
+    *out = static_cast<CType>(time);
+    return true;
+}
+
+constexpr long long min_seconds = file_time_type::duration::min().count()
+    / file_time_type::period::den;
+
+template <class SubSecDurT, class SubSecT>
+bool set_times_checked(time_t* sec_out, SubSecT* subsec_out, file_time_type tp) {
+    using namespace chrono;
+    auto dur = tp.time_since_epoch();
+    auto sec_dur = duration_cast<seconds>(dur);
+    auto subsec_dur = duration_cast<SubSecDurT>(dur - sec_dur);
+    // The tv_nsec and tv_usec fields must not be negative so adjust accordingly
+    if (subsec_dur.count() < 0) {
+        if (sec_dur.count() > min_seconds) {
+
+            sec_dur -= seconds(1);
+            subsec_dur += seconds(1);
+        } else {
+            subsec_dur = SubSecDurT::zero();
+        }
+    }
+    return checked_set(sec_out, sec_dur.count())
+        && checked_set(subsec_out, subsec_dur.count());
+}
+
+}} // end namespace detail
+
+
+file_time_type __last_write_time(const path& p, std::error_code *ec)
+{
+    std::error_code m_ec;
+    struct ::stat st;
+    detail::posix_stat(p, st, &m_ec);
+    if (m_ec) {
+        set_or_throw(m_ec, ec, "last_write_time", p);
+        return file_time_type::min();
+    }
+    if (ec) ec->clear();
+    return file_time_type::clock::from_time_t(st.st_mtime);
+}
+
+void __last_write_time(const path& p, file_time_type new_time,
+                       std::error_code *ec)
+{
+    using namespace std::chrono;
+    std::error_code m_ec;
+
+    // We can use the presence of UTIME_OMIT to detect platforms that do not
+    // provide utimensat.
+#if !defined(UTIME_OMIT)
+    // This implementation has a race condition between determining the
+    // last access time and attempting to set it to the same value using
+    // ::utimes
+    struct ::stat st;
+    file_status fst = detail::posix_stat(p, st, &m_ec);
+    if (m_ec && !status_known(fst)) {
+        set_or_throw(m_ec, ec, "last_write_time", p);
+        return;
+    }
+    struct ::timeval tbuf[2];
+    tbuf[0].tv_sec = st.st_atime;
+    tbuf[0].tv_usec = 0;
+    const bool overflowed = !detail::set_times_checked<microseconds>(
+        &tbuf[1].tv_sec, &tbuf[1].tv_usec, new_time);
+
+    if (overflowed) {
+        set_or_throw(make_error_code(errc::invalid_argument), ec,
+                     "last_write_time", p);
+        return;
+    }
+    if (::utimes(p.c_str(), tbuf) == -1) {
+        m_ec = detail::capture_errno();
+    }
+#else
+    struct ::timespec tbuf[2];
+    tbuf[0].tv_sec = 0;
+    tbuf[0].tv_nsec = UTIME_OMIT;
+
+    const bool overflowed = !detail::set_times_checked<nanoseconds>(
+        &tbuf[1].tv_sec, &tbuf[1].tv_nsec, new_time);
+    if (overflowed) {
+        set_or_throw(make_error_code(errc::invalid_argument),
+            ec, "last_write_time", p);
+        return;
+    }
+    if (::utimensat(AT_FDCWD, p.c_str(), tbuf, 0) == -1) {
+        m_ec = detail::capture_errno();
+    }
+#endif
+    if (m_ec)
+        set_or_throw(m_ec, ec, "last_write_time", p);
+    else if (ec)
+        ec->clear();
+}
+
+
+void __permissions(const path& p, perms prms, std::error_code *ec)
+{
+
+    const bool resolve_symlinks = !bool(perms::symlink_nofollow & prms);
+    const bool add_perms = bool(perms::add_perms & prms);
+    const bool remove_perms = bool(perms::remove_perms & prms);
+    _LIBCPP_ASSERT(!(add_perms && remove_perms),
+                   "Both add_perms and remove_perms are set");
+
+    bool set_sym_perms = false;
+    prms &= perms::mask;
+    if (!resolve_symlinks || (add_perms || remove_perms)) {
+        std::error_code m_ec;
+        file_status st = resolve_symlinks ? detail::posix_stat(p, &m_ec)
+                                          : detail::posix_lstat(p, &m_ec);
+        set_sym_perms = is_symlink(st);
+        if (m_ec) return set_or_throw(m_ec, ec, "permissions", p);
+        _LIBCPP_ASSERT(st.permissions() != perms::unknown,
+                       "Permissions unexpectedly unknown");
+        if (add_perms)
+            prms |= st.permissions();
+        else if (remove_perms)
+           prms = st.permissions() & ~prms;
+    }
+    const auto real_perms = detail::posix_convert_perms(prms);
+
+# if defined(AT_SYMLINK_NOFOLLOW) && defined(AT_FDCWD)
+    const int flags = set_sym_perms ? AT_SYMLINK_NOFOLLOW : 0;
+    if (::fchmodat(AT_FDCWD, p.c_str(), real_perms, flags) == -1) {
+        return set_or_throw(ec, "permissions", p);
+    }
+# else
+    if (set_sym_perms)
+        return set_or_throw(make_error_code(errc::operation_not_supported),
+                            ec, "permissions", p);
+    if (::chmod(p.c_str(), real_perms) == -1) {
+        return set_or_throw(ec, "permissions", p);
+    }
+# endif
+    if (ec) ec->clear();
+}
+
+
+path __read_symlink(const path& p, std::error_code *ec) {
+    char buff[PATH_MAX + 1];
+    std::error_code m_ec;
+    ::ssize_t ret;
+    if ((ret = ::readlink(p.c_str(), buff, PATH_MAX)) == -1) {
+        set_or_throw(ec, "read_symlink", p);
+        return {};
+    }
+    _LIBCPP_ASSERT(ret <= PATH_MAX, "TODO");
+    _LIBCPP_ASSERT(ret > 0, "TODO");
+    if (ec) ec->clear();
+    buff[ret] = 0;
+    return {buff};
+}
+
+
+bool __remove(const path& p, std::error_code *ec) {
+    if (ec) ec->clear();
+    if (::remove(p.c_str()) == -1) {
+        set_or_throw(ec, "remove", p);
+        return false;
+    }
+    return true;
+}
+
+namespace {
+
+std::uintmax_t remove_all_impl(path const & p, std::error_code& ec)
+{
+    const auto npos = static_cast<std::uintmax_t>(-1);
+    const file_status st = __symlink_status(p, &ec);
+    if (ec) return npos;
+     std::uintmax_t count = 1;
+    if (is_directory(st)) {
+        for (directory_iterator it(p, ec); !ec && it != directory_iterator();
+             it.increment(ec)) {
+            auto other_count = remove_all_impl(it->path(), ec);
+            if (ec) return npos;
+            count += other_count;
+        }
+        if (ec) return npos;
+    }
+    if (!__remove(p, &ec)) return npos;
+    return count;
+}
+
+} // end namespace
+
+std::uintmax_t __remove_all(const path& p, std::error_code *ec) {
+    std::error_code mec;
+    auto count = remove_all_impl(p, mec);
+    if (mec) {
+        set_or_throw(mec, ec, "remove_all", p);
+        return static_cast<std::uintmax_t>(-1);
+    }
+    if (ec) ec->clear();
+    return count;
+}
+
+void __rename(const path& from, const path& to, std::error_code *ec) {
+    if (::rename(from.c_str(), to.c_str()) == -1)
+        set_or_throw(ec, "rename", from, to);
+    else if (ec)
+        ec->clear();
+}
+
+void __resize_file(const path& p, std::uintmax_t size, std::error_code *ec) {
+    if (::truncate(p.c_str(), static_cast<long>(size)) == -1)
+        set_or_throw(ec, "resize_file", p);
+    else if (ec)
+        ec->clear();
+}
+
+space_info __space(const path& p, std::error_code *ec) {
+    space_info si;
+    struct statvfs m_svfs = {};
+    if (::statvfs(p.c_str(), &m_svfs) == -1)  {
+        set_or_throw(ec, "space", p);
+        si.capacity = si.free = si.available =
+            static_cast<std::uintmax_t>(-1);
+        return si;
+    }
+    if (ec) ec->clear();
+    // Multiply with overflow checking.
+    auto do_mult = [&](std::uintmax_t& out, std::uintmax_t other) {
+      out = other * m_svfs.f_frsize;
+      if (out / other != m_svfs.f_frsize || other == 0)
+          out = static_cast<std::uintmax_t>(-1);
+    };
+    do_mult(si.capacity, m_svfs.f_blocks);
+    do_mult(si.free, m_svfs.f_bfree);
+    do_mult(si.available, m_svfs.f_bavail);
+    return si;
+}
+
+file_status __status(const path& p, std::error_code *ec) {
+    return detail::posix_stat(p, ec);
+}
+
+file_status __symlink_status(const path& p, std::error_code *ec) {
+    return detail::posix_lstat(p, ec);
+}
+
+path __system_complete(const path& p, std::error_code *ec) {
+    if (ec) ec->clear();
+    return absolute(p, current_path());
+}
+
+path __temp_directory_path(std::error_code *ec) {
+    const char* env_paths[] = {"TMPDIR", "TMP", "TEMP", "TEMPDIR"};
+    const char* ret = nullptr;
+    for (auto & ep : env_paths)  {
+        if ((ret = std::getenv(ep)))
+            break;
+    }
+    path p(ret ? ret : "/tmp");
+    std::error_code m_ec;
+    if (is_directory(p, m_ec)) {
+        if (ec) ec->clear();
+        return p;
+    }
+    if (!m_ec || m_ec == make_error_code(errc::no_such_file_or_directory))
+        m_ec = make_error_code(errc::not_a_directory);
+    set_or_throw(m_ec, ec, "temp_directory_path");
+    return {};
+}
+
+// An absolute path is composed according to the table in [fs.op.absolute].
+path absolute(const path& p, const path& base) {
+    auto root_name = p.root_name();
+    auto root_dir = p.root_directory();
+
+    if (!root_name.empty() && !root_dir.empty())
+      return p;
+
+    auto abs_base = base.is_absolute() ? base : absolute(base);
+
+    /* !has_root_name && !has_root_dir */
+    if (root_name.empty() && root_dir.empty())
+    {
+      return abs_base / p;
+    }
+    else if (!root_name.empty()) /* has_root_name && !has_root_dir */
+    {
+      return  root_name / abs_base.root_directory()
+              /
+              abs_base.relative_path() / p.relative_path();
+    }
+    else /* !has_root_name && has_root_dir */
+    {
+      if (abs_base.has_root_name())
+        return abs_base.root_name() / p;
+      // else p is absolute,  return outside of block
+    }
+    return p;
+}
+
+_LIBCPP_END_NAMESPACE_EXPERIMENTAL_FILESYSTEM
diff --git a/src/experimental/filesystem/path.cpp b/src/experimental/filesystem/path.cpp
new file mode 100644
index 000000000000..38c449832f6e
--- /dev/null
+++ b/src/experimental/filesystem/path.cpp
@@ -0,0 +1,391 @@
+//===--------------------- filesystem/path.cpp ----------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+#include "experimental/filesystem"
+#include "experimental/string_view"
+#include "utility"
+
+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM
+
+_LIBCPP_CONSTEXPR path::value_type path::preferred_separator;
+
+namespace { namespace parser
+{
+
+using string_type = string_view;
+using value_type = path::value_type;
+
+using string_view_pair = pair<string_view, string_view>;
+
+// status reporting
+constexpr size_t npos = static_cast<size_t>(-1);
+
+inline bool good(size_t pos) { return pos != npos; }
+
+// lexical elements
+constexpr value_type preferred_separator = path::preferred_separator;
+constexpr value_type const * preferred_separator_str = "/";
+constexpr value_type const * dot = ".";
+
+// forward //
+bool is_separator(string_type const &, size_t);
+bool is_root_name(const string_type&, size_t);
+bool is_root_directory(string_type const &, size_t);
+bool is_trailing_separator(string_type const &, size_t);
+
+size_t start_of(string_type const &, size_t);
+size_t end_of(string_type const &, size_t);
+
+size_t root_name_start(const string_type& s);
+size_t root_name_end(const string_type&);
+
+size_t root_directory_start(string_type const &);
+size_t root_directory_end(string_type const &);
+
+string_view_pair separate_filename(string_type const &);
+string_view extract_raw(string_type const &, size_t);
+string_view extract_preferred(string_type const &, size_t);
+
+inline bool is_separator(const string_type& s, size_t pos) {
+    return (pos < s.size() && s[pos] == preferred_separator);
+}
+
+inline bool is_root_name(const string_type& s, size_t pos) {
+  return good(pos) && pos == 0 ? root_name_start(s) == pos : false;
+}
+
+inline bool is_root_directory(const string_type& s, size_t pos) {
+    return good(pos) ? root_directory_start(s) == pos : false;
+}
+
+inline bool is_trailing_separator(const string_type& s, size_t pos) {
+    return (pos < s.size() && is_separator(s, pos) &&
+            end_of(s, pos) == s.size()-1 &&
+            !is_root_directory(s, pos) && !is_root_name(s, pos));
+}
+
+size_t start_of(const string_type& s, size_t pos) {
+    if (pos >= s.size()) return npos;
+    bool in_sep = (s[pos] == preferred_separator);
+    while (pos - 1 < s.size() &&
+        (s[pos-1] == preferred_separator) == in_sep)
+    { --pos; }
+    if (pos == 2 && !in_sep && s[0] == preferred_separator &&
+        s[1] == preferred_separator)
+    { return 0; }
+    return pos;
+}
+
+size_t end_of(const string_type& s, size_t pos) {
+    if (pos >= s.size()) return npos;
+    // special case for root name
+    if (pos == 0 && is_root_name(s, pos)) return root_name_end(s);
+    bool in_sep = (s[pos] == preferred_separator);
+    while (pos + 1 < s.size() && (s[pos+1] == preferred_separator) == in_sep)
+    { ++pos; }
+    return pos;
+}
+
+inline size_t root_name_start(const string_type& s) {
+    return good(root_name_end(s)) ? 0 : npos;
+}
+
+size_t root_name_end(const string_type& s) {
+    if (s.size() < 2 || s[0] != preferred_separator
+        || s[1] != preferred_separator) {
+        return npos;
+    }
+    if (s.size() == 2) {
+        return 1;
+    }
+    size_t index = 2; // current position
+    if (s[index] == preferred_separator) {
+        return npos;
+    }
+    while (index + 1 < s.size() && s[index+1] != preferred_separator) {
+        ++index;
+    }
+    return index;
+}
+
+size_t root_directory_start(const string_type& s) {
+    size_t e = root_name_end(s);
+    if (!good(e))
+    return is_separator(s, 0) ? 0 : npos;
+    return is_separator(s, e + 1) ? e + 1 : npos;
+}
+
+size_t root_directory_end(const string_type& s) {
+    size_t st = root_directory_start(s);
+    if (!good(st)) return npos;
+    size_t index = st;
+    while (index + 1 < s.size() && s[index + 1] == preferred_separator)
+      { ++index; }
+    return index;
+}
+
+string_view_pair separate_filename(string_type const & s) {
+    if (s == "." || s == ".." || s.empty()) return string_view_pair{s, ""};
+    auto pos = s.find_last_of('.');
+    if (pos == string_type::npos) return string_view_pair{s, string_view{}};
+    return string_view_pair{s.substr(0, pos), s.substr(pos)};
+}
+
+inline string_view extract_raw(const string_type& s, size_t pos) {
+    size_t end_i = end_of(s, pos);
+    if (!good(end_i)) return string_view{};
+    return string_view(s).substr(pos, end_i - pos + 1);
+}
+
+string_view extract_preferred(const string_type& s, size_t pos) {
+    string_view raw = extract_raw(s, pos);
+    if (raw.empty())
+        return raw;
+    if (is_trailing_separator(s, pos))
+        return string_view{dot};
+    if (is_separator(s, pos) && !is_root_name(s, pos))
+        return string_view(preferred_separator_str);
+    return raw;
+}
+
+}} // namespace parser
+
+
+////////////////////////////////////////////////////////////////////////////////
+//                            path_view_iterator
+////////////////////////////////////////////////////////////////////////////////
+namespace {
+
+struct path_view_iterator {
+  const string_view __s_;
+  size_t __pos_;
+
+  explicit path_view_iterator(string_view const& __s) : __s_(__s), __pos_(__s_.empty() ? parser::npos : 0) {}
+  explicit path_view_iterator(string_view const& __s, size_t __p) : __s_(__s), __pos_(__p) {}
+
+  string_view operator*() const {
+    return parser::extract_preferred(__s_, __pos_);
+  }
+
+  path_view_iterator& operator++() {
+    increment();
+    return *this;
+  }
+
+  path_view_iterator& operator--() {
+    decrement();
+    return *this;
+  }
+
+  void increment() {
+    if (__pos_ == parser::npos) return;
+    while (! set_position(parser::end_of(__s_, __pos_)+1))
+        ;
+    return;
+  }
+
+  void decrement() {
+    if (__pos_ == 0) {
+      set_position(0);
+    }
+    else if (__pos_ == parser::npos) {
+      auto const str_size = __s_.size();
+      set_position(parser::start_of(
+          __s_, str_size != 0 ? str_size - 1 : str_size));
+    } else {
+      while (!set_position(parser::start_of(__s_, __pos_-1)))
+        ;
+    }
+  }
+
+  bool set_position(size_t pos) {
+    if (pos >= __s_.size()) {
+      __pos_ = parser::npos;
+    } else {
+      __pos_ = pos;
+    }
+    return valid_iterator_position();
+  }
+
+  bool valid_iterator_position() const {
+    if (__pos_ == parser::npos) return true; // end position is valid
+    return (!parser::is_separator      (__s_, __pos_) ||
+          parser::is_root_directory    (__s_, __pos_) ||
+          parser::is_trailing_separator(__s_, __pos_) ||
+          parser::is_root_name         (__s_, __pos_));
+  }
+
+  bool is_end() const { return __pos_ == parser::npos; }
+
+  inline bool operator==(path_view_iterator const& __p) {
+      return __pos_ == __p.__pos_;
+  }
+};
+
+path_view_iterator pbegin(path const& p) {
+    return path_view_iterator(p.native());
+}
+
+path_view_iterator pend(path const& p) {
+    path_view_iterator __p(p.native());
+    __p.__pos_ = parser::npos;
+    return __p;
+}
+
+} // end namespace
+///////////////////////////////////////////////////////////////////////////////
+//                            path definitions
+///////////////////////////////////////////////////////////////////////////////
+
+path & path::replace_extension(path const & replacement)
+{
+    path p = extension();
+    if (not p.empty()) {
+      __pn_.erase(__pn_.size() - p.native().size());
+    }
+    if (!replacement.empty()) {
+        if (replacement.native()[0] != '.') {
+            __pn_ += ".";
+        }
+        __pn_.append(replacement.__pn_);
+    }
+    return *this;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// path.decompose
+
+string_view path::__root_name() const
+{
+    return parser::is_root_name(__pn_, 0)
+      ? parser::extract_preferred(__pn_, 0)
+      : string_view{};
+}
+
+string_view path::__root_directory() const
+{
+    auto start_i = parser::root_directory_start(__pn_);
+    if(!parser::good(start_i)) {
+        return {};
+    }
+    return parser::extract_preferred(__pn_, start_i);
+}
+
+string_view path::__relative_path() const
+{
+    if (empty()) {
+        return {__pn_};
+    }
+    auto end_i = parser::root_directory_end(__pn_);
+    if (not parser::good(end_i)) {
+        end_i = parser::root_name_end(__pn_);
+    }
+    if (not parser::good(end_i)) {
+        return {__pn_};
+    }
+    return string_view(__pn_).substr(end_i+1);
+}
+
+string_view path::__parent_path() const
+{
+    if (empty() || pbegin(*this) == --pend(*this)) {
+        return {};
+    }
+    auto end_it = --(--pend(*this));
+    auto end_i = parser::end_of(__pn_, end_it.__pos_);
+    return string_view(__pn_).substr(0, end_i+1);
+}
+
+string_view path::__filename() const
+{
+    return empty() ? string_view{} : *--pend(*this);
+}
+
+string_view path::__stem() const
+{
+    return parser::separate_filename(__filename()).first;
+}
+
+string_view path::__extension() const
+{
+    return parser::separate_filename(__filename()).second;
+}
+
+////////////////////////////////////////////////////////////////////////////
+// path.comparisons
+int path::__compare(const value_type* __s) const {
+    path_view_iterator thisIter(this->native());
+    path_view_iterator sIter(__s);
+    while (!thisIter.is_end() && !sIter.is_end()) {
+        int res = (*thisIter).compare(*sIter);
+        if (res != 0) return res;
+        ++thisIter; ++sIter;
+    }
+    if (thisIter.is_end() && sIter.is_end())
+        return 0;
+    if (thisIter.is_end())
+        return -1;
+    return 1;
+}
+
+////////////////////////////////////////////////////////////////////////////
+// path.nonmembers
+size_t hash_value(const path& __p) _NOEXCEPT {
+  path_view_iterator thisIter(__p.native());
+  struct HashPairT {
+    size_t first;
+    size_t second;
+  };
+  HashPairT hp = {0, 0};
+  std::hash<string_view> hasher;
+  std::__scalar_hash<decltype(hp)> pair_hasher;
+  while (!thisIter.is_end()) {
+    hp.second = hasher(*thisIter);
+    hp.first = pair_hasher(hp);
+    ++thisIter;
+  }
+  return hp.first;
+}
+
+////////////////////////////////////////////////////////////////////////////
+// path.itr
+path::iterator path::begin() const
+{
+    path_view_iterator pit = pbegin(*this);
+    iterator it;
+    it.__path_ptr_ = this;
+    it.__pos_ = pit.__pos_;
+    it.__elem_.__assign_view(*pit);
+    return it;
+}
+
+path::iterator path::end() const
+{
+    iterator it{};
+    it.__path_ptr_ = this;
+    it.__pos_ = parser::npos;
+    return it;
+}
+
+path::iterator& path::iterator::__increment() {
+  path_view_iterator it(__path_ptr_->native(), __pos_);
+  it.increment();
+  __pos_ = it.__pos_;
+  __elem_.__assign_view(*it);
+  return *this;
+}
+
+path::iterator& path::iterator::__decrement() {
+  path_view_iterator it(__path_ptr_->native(), __pos_);
+  it.decrement();
+  __pos_ = it.__pos_;
+  __elem_.__assign_view(*it);
+  return *this;
+}
+
+_LIBCPP_END_NAMESPACE_EXPERIMENTAL_FILESYSTEM
diff --git a/src/experimental/memory_resource.cpp b/src/experimental/memory_resource.cpp
new file mode 100644
index 000000000000..c01eb0823bae
--- /dev/null
+++ b/src/experimental/memory_resource.cpp
@@ -0,0 +1,144 @@
+//===------------------------ memory_resource.cpp -------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+#include "experimental/memory_resource"
+
+#ifndef _LIBCPP_HAS_NO_ATOMIC_HEADER
+#include "atomic"
+#elif !defined(_LIBCPP_HAS_NO_THREADS)
+#include "mutex"
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
+
+// memory_resource
+
+//memory_resource::~memory_resource() {}
+
+// new_delete_resource()
+
+class _LIBCPP_TYPE_VIS_ONLY __new_delete_memory_resource_imp
+    : public memory_resource
+{
+public:
+    ~__new_delete_memory_resource_imp() = default;
+
+protected:
+    virtual void* do_allocate(size_t __size, size_t __align)
+        { return __allocate(__size); }
+
+    virtual void do_deallocate(void * __p, size_t, size_t)
+        { __deallocate(__p); }
+
+    virtual bool do_is_equal(memory_resource const & __other) const _NOEXCEPT
+        { return &__other == this; }
+};
+
+// null_memory_resource()
+
+class _LIBCPP_TYPE_VIS_ONLY __null_memory_resource_imp
+    : public memory_resource
+{
+public:
+    ~__null_memory_resource_imp() = default;
+
+protected:
+    virtual void* do_allocate(size_t, size_t) {
+#ifndef _LIBCPP_NO_EXCEPTIONS
+        throw std::bad_alloc();
+#else
+        abort();
+#endif
+    }
+    virtual void do_deallocate(void *, size_t, size_t) {}
+    virtual bool do_is_equal(memory_resource const & __other) const _NOEXCEPT
+    { return &__other == this; }
+};
+
+namespace {
+
+union ResourceInitHelper {
+  struct {
+    __new_delete_memory_resource_imp new_delete_res;
+    __null_memory_resource_imp       null_res;
+  } resources;
+  char dummy;
+  _LIBCPP_CONSTEXPR_AFTER_CXX11 ResourceInitHelper() : resources() {}
+  ~ResourceInitHelper() {}
+};
+// When compiled in C++14 this initialization should be a constant expression.
+// Only in C++11 is "init_priority" needed to ensure initialization order.
+ResourceInitHelper res_init __attribute__((init_priority (101)));
+
+} // end namespace
+
+
+memory_resource * new_delete_resource() _NOEXCEPT {
+    return &res_init.resources.new_delete_res;
+}
+
+memory_resource * null_memory_resource() _NOEXCEPT {
+    return &res_init.resources.null_res;
+}
+
+// default_memory_resource()
+
+static memory_resource *
+__default_memory_resource(bool set = false, memory_resource * new_res = nullptr) _NOEXCEPT
+{
+#ifndef _LIBCPP_HAS_NO_ATOMIC_HEADER
+    static atomic<memory_resource*> __res =
+        ATOMIC_VAR_INIT(&res_init.resources.new_delete_res);
+    if (set) {
+        new_res = new_res ? new_res : new_delete_resource();
+        // TODO: Can a weaker ordering be used?
+        return _VSTD::atomic_exchange_explicit(
+            &__res, new_res, memory_order::memory_order_acq_rel);
+    }
+    else {
+        return _VSTD::atomic_load_explicit(
+            &__res, memory_order::memory_order_acquire);
+    }
+#elif !defined(_LIBCPP_HAS_NO_THREADS)
+    static memory_resource * res = &res_init.resources.new_delete_res;
+    static mutex res_lock;
+    if (set) {
+        new_res = new_res ? new_res : new_delete_resource();
+        lock_guard<mutex> guard(res_lock);
+        memory_resource * old_res = res;
+        res = new_res;
+        return old_res;
+    } else {
+        lock_guard<mutex> guard(res_lock);
+        return res;
+    }
+#else
+    static memory_resource* res = &res_init.resources.new_delete_res;
+    if (set) {
+        new_res = new_res ? new_res : new_delete_resource();
+        memory_resource * old_res = res;
+        res = new_res;
+        return old_res;
+    } else {
+        return res;
+    }
+#endif
+}
+
+memory_resource * get_default_resource() _NOEXCEPT
+{
+    return __default_memory_resource();
+}
+
+memory_resource * set_default_resource(memory_resource * __new_res) _NOEXCEPT
+{
+    return __default_memory_resource(true, __new_res);
+}
+
+_LIBCPP_END_NAMESPACE_LFTS_PMR
\ No newline at end of file
diff --git a/src/locale.cpp b/src/locale.cpp
index 6b04e7881764..da2fd11678d6 100644
--- a/src/locale.cpp
+++ b/src/locale.cpp
@@ -123,11 +123,6 @@ const locale::category locale::time;
 const locale::category locale::messages;
 const locale::category locale::all;
 
-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-
 class _LIBCPP_HIDDEN locale::__imp
     : public facet
 {
@@ -163,10 +158,6 @@ private:
     template <class F> void install_from(const __imp& other);
 };
 
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif
-
 locale::__imp::__imp(size_t refs)
     : facet(refs),
       facets_(N),
@@ -1409,33 +1400,21 @@ ctype_byname<wchar_t>::do_tolower(char_type* low, const char_type* high) const
 wchar_t
 ctype_byname<wchar_t>::do_widen(char c) const
 {
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-    return btowc_l(c, __l);
-#else
-    return __btowc_l(c, __l);
-#endif
+    return __libcpp_btowc_l(c, __l);
 }
 
 const char*
 ctype_byname<wchar_t>::do_widen(const char* low, const char* high, char_type* dest) const
 {
     for (; low != high; ++low, ++dest)
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-        *dest = btowc_l(*low, __l);
-#else
-        *dest = __btowc_l(*low, __l);
-#endif
+        *dest = __libcpp_btowc_l(*low, __l);
     return low;
 }
 
 char
 ctype_byname<wchar_t>::do_narrow(char_type c, char dfault) const
 {
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-    int r = wctob_l(c, __l);
-#else
-    int r = __wctob_l(c, __l);
-#endif
+    int r = __libcpp_wctob_l(c, __l);
     return r != static_cast<int>(WEOF) ? static_cast<char>(r) : dfault;
 }
 
@@ -1444,11 +1423,7 @@ ctype_byname<wchar_t>::do_narrow(const char_type* low, const char_type* high, ch
 {
     for (; low != high; ++low, ++dest)
     {
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-        int r = wctob_l(*low, __l);
-#else
-        int r = __wctob_l(*low, __l);
-#endif
+        int r = __libcpp_wctob_l(*low, __l);
         *dest = r != static_cast<int>(WEOF) ? static_cast<char>(r) : dfault;
     }
     return low;
@@ -1558,22 +1533,14 @@ codecvt<wchar_t, char, mbstate_t>::do_out(state_type& st,
     {
         // save state in case it is needed to recover to_nxt on error
         mbstate_t save_state = st;
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-        size_t n = wcsnrtombs_l(to, &frm_nxt, static_cast<size_t>(fend-frm),
-                                static_cast<size_t>(to_end-to), &st, __l);
-#else
-        size_t n = __wcsnrtombs_l(to, &frm_nxt, fend-frm, to_end-to, &st, __l);
-#endif
+        size_t n = __libcpp_wcsnrtombs_l(to, &frm_nxt, static_cast<size_t>(fend-frm),
+                                     static_cast<size_t>(to_end-to), &st, __l);
         if (n == size_t(-1))
         {
             // need to recover to_nxt
             for (to_nxt = to; frm != frm_nxt; ++frm)
             {
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-                n = wcrtomb_l(to_nxt, *frm, &save_state, __l);
-#else
-                n = __wcrtomb_l(to_nxt, *frm, &save_state, __l);
-#endif
+                n = __libcpp_wcrtomb_l(to_nxt, *frm, &save_state, __l);
                 if (n == size_t(-1))
                     break;
                 to_nxt += n;
@@ -1590,11 +1557,7 @@ codecvt<wchar_t, char, mbstate_t>::do_out(state_type& st,
         {
             // Try to write the terminating null
             extern_type tmp[MB_LEN_MAX];
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-            n = wcrtomb_l(tmp, intern_type(), &st, __l);
-#else
-            n = __wcrtomb_l(tmp, intern_type(), &st, __l);
-#endif
+            n = __libcpp_wcrtomb_l(tmp, intern_type(), &st, __l);
             if (n == size_t(-1))  // on error
                 return error;
             if (n > static_cast<size_t>(to_end-to_nxt))  // is there room?
@@ -1627,23 +1590,15 @@ codecvt<wchar_t, char, mbstate_t>::do_in(state_type& st,
     {
         // save state in case it is needed to recover to_nxt on error
         mbstate_t save_state = st;
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-        size_t n = mbsnrtowcs_l(to, &frm_nxt, static_cast<size_t>(fend-frm),
-                                static_cast<size_t>(to_end-to), &st, __l);
-#else
-        size_t n = __mbsnrtowcs_l(to, &frm_nxt, fend-frm, to_end-to, &st, __l);
-#endif
+        size_t n = __libcpp_mbsnrtowcs_l(to, &frm_nxt, static_cast<size_t>(fend-frm),
+                                     static_cast<size_t>(to_end-to), &st, __l);
         if (n == size_t(-1))
         {
             // need to recover to_nxt
             for (to_nxt = to; frm != frm_nxt; ++to_nxt)
             {
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-                n = mbrtowc_l(to_nxt, frm, static_cast<size_t>(fend-frm),
-                              &save_state, __l);
-#else
-                n = __mbrtowc_l(to_nxt, frm, fend-frm, &save_state, __l);
-#endif
+                n = __libcpp_mbrtowc_l(to_nxt, frm, static_cast<size_t>(fend-frm),
+                                   &save_state, __l);
                 switch (n)
                 {
                 case 0:
@@ -1671,11 +1626,7 @@ codecvt<wchar_t, char, mbstate_t>::do_in(state_type& st,
         if (fend != frm_end)  // set up next null terminated sequence
         {
             // Try to write the terminating null
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-            n = mbrtowc_l(to_nxt, frm_nxt, 1, &st, __l);
-#else
-            n = __mbrtowc_l(to_nxt, frm_nxt, 1, &st, __l);
-#endif
+            n = __libcpp_mbrtowc_l(to_nxt, frm_nxt, 1, &st, __l);
             if (n != 0)  // on error
                 return error;
             ++to_nxt;
@@ -1695,11 +1646,7 @@ codecvt<wchar_t, char, mbstate_t>::do_unshift(state_type& st,
 {
     to_nxt = to;
     extern_type tmp[MB_LEN_MAX];
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-    size_t n = wcrtomb_l(tmp, intern_type(), &st, __l);
-#else
-    size_t n = __wcrtomb_l(tmp, intern_type(), &st, __l);
-#endif
+    size_t n = __libcpp_wcrtomb_l(tmp, intern_type(), &st, __l);
     if (n == size_t(-1) || n == 0)  // on error
         return error;
     --n;
@@ -1713,21 +1660,11 @@ codecvt<wchar_t, char, mbstate_t>::do_unshift(state_type& st,
 int
 codecvt<wchar_t, char, mbstate_t>::do_encoding() const  _NOEXCEPT
 {
-#ifndef __CloudABI__
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-    if (mbtowc_l(nullptr, nullptr, MB_LEN_MAX, __l) != 0)
-#else
-    if (__mbtowc_l(nullptr, nullptr, MB_LEN_MAX, __l) != 0)
-#endif
+    if (__libcpp_mbtowc_l(nullptr, nullptr, MB_LEN_MAX, __l) != 0)
         return -1;
-#endif
 
     // stateless encoding
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-    if (__l == 0 || MB_CUR_MAX_L(__l) == 1)  // there are no known constant length encodings
-#else
-    if (__l == 0 || __mb_cur_max_l(__l) == 1)  // there are no known constant length encodings
-#endif
+    if (__l == 0 || __libcpp_mb_cur_max_l(__l) == 1)  // there are no known constant length encodings
         return 1;                // which take more than 1 char to form a wchar_t
     return 0;
 }
@@ -1745,11 +1682,7 @@ codecvt<wchar_t, char, mbstate_t>::do_length(state_type& st,
     int nbytes = 0;
     for (size_t nwchar_t = 0; nwchar_t < mx && frm != frm_end; ++nwchar_t)
     {
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-        size_t n = mbrlen_l(frm, static_cast<size_t>(frm_end-frm), &st, __l);
-#else
-        size_t n = __mbrlen_l(frm, frm_end-frm, &st, __l);
-#endif
+        size_t n = __libcpp_mbrlen_l(frm, static_cast<size_t>(frm_end-frm), &st, __l);
         switch (n)
         {
         case 0:
@@ -1771,11 +1704,7 @@ codecvt<wchar_t, char, mbstate_t>::do_length(state_type& st,
 int
 codecvt<wchar_t, char, mbstate_t>::do_max_length() const  _NOEXCEPT
 {
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-    return __l == 0 ? 1 : static_cast<int>(  MB_CUR_MAX_L(__l));
-#else
-    return __l == 0 ? 1 : static_cast<int>(__mb_cur_max_l(__l));
-#endif
+    return __l == 0 ? 1 : static_cast<int>(__libcpp_mb_cur_max_l(__l));
 }
 
 //                                     Valid UTF ranges
@@ -2894,10 +2823,10 @@ ucs4_to_utf16le(const uint32_t* frm, const uint32_t* frm_end, const uint32_t*& f
     to_nxt = to;
     if (mode & generate_header)
     {
-        if (to_end-to_nxt < 2)
+        if (to_end - to_nxt < 2)
             return codecvt_base::partial;
-            *to_nxt++ = static_cast<uint8_t>(0xFF);
-            *to_nxt++ = static_cast<uint8_t>(0xFE);
+        *to_nxt++ = static_cast<uint8_t>(0xFF);
+        *to_nxt++ = static_cast<uint8_t>(0xFE);
     }
     for (; frm_nxt < frm_end; ++frm_nxt)
     {
@@ -4333,11 +4262,7 @@ numpunct_byname<char>::__init(const char* nm)
             throw runtime_error("numpunct_byname<char>::numpunct_byname"
                                 " failed to construct for " + string(nm));
 #endif  // _LIBCPP_NO_EXCEPTIONS
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-        lconv* lc = localeconv_l(loc.get());
-#else
-        lconv* lc = __localeconv_l(loc.get());
-#endif
+        lconv* lc = __libcpp_localeconv_l(loc.get());
         if (*lc->decimal_point)
             __decimal_point_ = *lc->decimal_point;
         if (*lc->thousands_sep)
@@ -4376,11 +4301,7 @@ numpunct_byname<wchar_t>::__init(const char* nm)
             throw runtime_error("numpunct_byname<char>::numpunct_byname"
                                 " failed to construct for " + string(nm));
 #endif  // _LIBCPP_NO_EXCEPTIONS
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-        lconv* lc = localeconv_l(loc.get());
-#else
-        lconv* lc = __localeconv_l(loc.get());
-#endif
+        lconv* lc = __libcpp_localeconv_l(loc.get());
         if (*lc->decimal_point)
             __decimal_point_ = *lc->decimal_point;
         if (*lc->thousands_sep)
@@ -4981,11 +4902,7 @@ __time_get_storage<wchar_t>::__analyze(char fmt, const ctype<wchar_t>& ct)
     wchar_t* wbb = wbuf;
     mbstate_t mb = {0};
     const char* bb = buf;
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-    size_t j = mbsrtowcs_l( wbb, &bb, countof(wbuf), &mb, __loc_);
-#else
-    size_t j = __mbsrtowcs_l( wbb, &bb, countof(wbuf), &mb, __loc_);
-#endif
+    size_t j = __libcpp_mbsrtowcs_l( wbb, &bb, countof(wbuf), &mb, __loc_);
     if (j == size_t(-1))
         __throw_runtime_error("locale not supported");
     wchar_t* wbe = wbb + j;
@@ -5165,11 +5082,7 @@ __time_get_storage<wchar_t>::init(const ctype<wchar_t>& ct)
         strftime_l(buf, countof(buf), "%A", &t, __loc_);
         mb = mbstate_t();
         const char* bb = buf;
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-        size_t j = mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
-#else
-        size_t j = __mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
-#endif
+        size_t j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
         if (j == size_t(-1))
             __throw_runtime_error("locale not supported");
         wbe = wbuf + j;
@@ -5177,11 +5090,7 @@ __time_get_storage<wchar_t>::init(const ctype<wchar_t>& ct)
         strftime_l(buf, countof(buf), "%a", &t, __loc_);
         mb = mbstate_t();
         bb = buf;
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-        j = mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
-#else
-        j = __mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
-#endif
+        j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
         if (j == size_t(-1))
             __throw_runtime_error("locale not supported");
         wbe = wbuf + j;
@@ -5194,11 +5103,7 @@ __time_get_storage<wchar_t>::init(const ctype<wchar_t>& ct)
         strftime_l(buf, countof(buf), "%B", &t, __loc_);
         mb = mbstate_t();
         const char* bb = buf;
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-        size_t j = mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
-#else
-        size_t j = __mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
-#endif
+        size_t j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
         if (j == size_t(-1))
             __throw_runtime_error("locale not supported");
         wbe = wbuf + j;
@@ -5206,11 +5111,7 @@ __time_get_storage<wchar_t>::init(const ctype<wchar_t>& ct)
         strftime_l(buf, countof(buf), "%b", &t, __loc_);
         mb = mbstate_t();
         bb = buf;
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-        j = mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
-#else
-        j = __mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
-#endif
+        j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
         if (j == size_t(-1))
             __throw_runtime_error("locale not supported");
         wbe = wbuf + j;
@@ -5221,11 +5122,7 @@ __time_get_storage<wchar_t>::init(const ctype<wchar_t>& ct)
     strftime_l(buf, countof(buf), "%p", &t, __loc_);
     mb = mbstate_t();
     const char* bb = buf;
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-    size_t j = mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
-#else
-    size_t j = __mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
-#endif
+    size_t j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
     if (j == size_t(-1))
         __throw_runtime_error("locale not supported");
     wbe = wbuf + j;
@@ -5234,11 +5131,7 @@ __time_get_storage<wchar_t>::init(const ctype<wchar_t>& ct)
     strftime_l(buf, countof(buf), "%p", &t, __loc_);
     mb = mbstate_t();
     bb = buf;
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-    j = mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
-#else
-    j = __mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
-#endif
+    j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
     if (j == size_t(-1))
         __throw_runtime_error("locale not supported");
     wbe = wbuf + j;
@@ -5513,11 +5406,7 @@ __time_put::__do_put(wchar_t* __wb, wchar_t*& __we, const tm* __tm,
     __do_put(__nar, __ne, __tm, __fmt, __mod);
     mbstate_t mb = {0};
     const char* __nb = __nar;
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-    size_t j = mbsrtowcs_l(__wb, &__nb, countof(__wb, __we), &mb, __loc_);
-#else
-    size_t j = __mbsrtowcs_l(__wb, &__nb, countof(__wb, __we), &mb, __loc_);
-#endif
+    size_t j = __libcpp_mbsrtowcs_l(__wb, &__nb, countof(__wb, __we), &mb, __loc_);
     if (j == size_t(-1))
         __throw_runtime_error("locale not supported");
     __we = __wb + j;
@@ -5908,11 +5797,7 @@ moneypunct_byname<char, false>::init(const char* nm)
         throw runtime_error("moneypunct_byname"
                             " failed to construct for " + string(nm));
 #endif  // _LIBCPP_NO_EXCEPTIONS
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-    lconv* lc = localeconv_l(loc.get());
-#else
-    lconv* lc = __localeconv_l(loc.get());
-#endif
+    lconv* lc = __libcpp_localeconv_l(loc.get());
     if (*lc->mon_decimal_point)
         __decimal_point_ = *lc->mon_decimal_point;
     else
@@ -5956,11 +5841,7 @@ moneypunct_byname<char, true>::init(const char* nm)
         throw runtime_error("moneypunct_byname"
                             " failed to construct for " + string(nm));
 #endif  // _LIBCPP_NO_EXCEPTIONS
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-    lconv* lc = localeconv_l(loc.get());
-#else
-    lconv* lc = __localeconv_l(loc.get());
-#endif
+    lconv* lc = __libcpp_localeconv_l(loc.get());
     if (*lc->mon_decimal_point)
         __decimal_point_ = *lc->mon_decimal_point;
     else
@@ -6021,11 +5902,7 @@ moneypunct_byname<wchar_t, false>::init(const char* nm)
         throw runtime_error("moneypunct_byname"
                             " failed to construct for " + string(nm));
 #endif  // _LIBCPP_NO_EXCEPTIONS
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-    lconv* lc = localeconv_l(loc.get());
-#else
-    lconv* lc = __localeconv_l(loc.get());
-#endif
+    lconv* lc = __libcpp_localeconv_l(loc.get());
     if (*lc->mon_decimal_point)
         __decimal_point_ = static_cast<wchar_t>(*lc->mon_decimal_point);
     else
@@ -6038,11 +5915,7 @@ moneypunct_byname<wchar_t, false>::init(const char* nm)
     wchar_t wbuf[100];
     mbstate_t mb = {0};
     const char* bb = lc->currency_symbol;
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-    size_t j = mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
-#else
-    size_t j = __mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
-#endif
+    size_t j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
     if (j == size_t(-1))
         __throw_runtime_error("locale not supported");
     wchar_t* wbe = wbuf + j;
@@ -6057,11 +5930,7 @@ moneypunct_byname<wchar_t, false>::init(const char* nm)
     {
         mb = mbstate_t();
         bb = lc->positive_sign;
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-        j = mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
-#else
-        j = __mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
-#endif
+        j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
         if (j == size_t(-1))
             __throw_runtime_error("locale not supported");
         wbe = wbuf + j;
@@ -6073,11 +5942,7 @@ moneypunct_byname<wchar_t, false>::init(const char* nm)
     {
         mb = mbstate_t();
         bb = lc->negative_sign;
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-        j = mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
-#else
-        j = __mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
-#endif
+        j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
         if (j == size_t(-1))
             __throw_runtime_error("locale not supported");
         wbe = wbuf + j;
@@ -6104,11 +5969,7 @@ moneypunct_byname<wchar_t, true>::init(const char* nm)
         throw runtime_error("moneypunct_byname"
                             " failed to construct for " + string(nm));
 #endif  // _LIBCPP_NO_EXCEPTIONS
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-    lconv* lc = localeconv_l(loc.get());
-#else
-    lconv* lc = __localeconv_l(loc.get());
-#endif
+    lconv* lc = __libcpp_localeconv_l(loc.get());
     if (*lc->mon_decimal_point)
         __decimal_point_ = static_cast<wchar_t>(*lc->mon_decimal_point);
     else
@@ -6121,11 +5982,7 @@ moneypunct_byname<wchar_t, true>::init(const char* nm)
     wchar_t wbuf[100];
     mbstate_t mb = {0};
     const char* bb = lc->int_curr_symbol;
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-    size_t j = mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
-#else
-    size_t j = __mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
-#endif
+    size_t j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
     if (j == size_t(-1))
         __throw_runtime_error("locale not supported");
     wchar_t* wbe = wbuf + j;
@@ -6144,11 +6001,7 @@ moneypunct_byname<wchar_t, true>::init(const char* nm)
     {
         mb = mbstate_t();
         bb = lc->positive_sign;
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-        j = mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
-#else
-        j = __mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
-#endif
+        j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
         if (j == size_t(-1))
             __throw_runtime_error("locale not supported");
         wbe = wbuf + j;
@@ -6164,11 +6017,7 @@ moneypunct_byname<wchar_t, true>::init(const char* nm)
     {
         mb = mbstate_t();
         bb = lc->negative_sign;
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-        j = mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
-#else
-        j = __mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
-#endif
+        j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
         if (j == size_t(-1))
             __throw_runtime_error("locale not supported");
         wbe = wbuf + j;
diff --git a/src/memory.cpp b/src/memory.cpp
index 5b81f26e3dc0..15e947fc0ff8 100644
--- a/src/memory.cpp
+++ b/src/memory.cpp
@@ -124,15 +124,15 @@ __shared_weak_count::__get_deleter(const type_info&) const _NOEXCEPT
 
 #endif  // _LIBCPP_NO_RTTI
 
-#if defined(_LIBCPP_HAS_C_ATOMIC_IMP) && !defined(_LIBCPP_HAS_NO_THREADS)
+#if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
 
 static const std::size_t __sp_mut_count = 16;
-static pthread_mutex_t mut_back_imp[__sp_mut_count] =
+static __libcpp_mutex_t mut_back_imp[__sp_mut_count] =
 {
-    PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER,
-    PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER,
-    PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER,
-    PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER
+    _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER,
+    _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER,
+    _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER,
+    _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER
 };
 
 static mutex* mut_back = reinterpret_cast<std::mutex*>(mut_back_imp);
@@ -177,7 +177,7 @@ __get_sp_mut(const void* p)
     return muts[hash<const void*>()(p) & (__sp_mut_count-1)];
 }
 
-#endif // defined(_LIBCPP_HAS_C_ATOMIC_IMP) && !defined(_LIBCPP_HAS_NO_THREADS)
+#endif // !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
 
 void
 declare_reachable(void*)
diff --git a/src/mutex.cpp b/src/mutex.cpp
index 127e67a2627e..9f808ca5076c 100644
--- a/src/mutex.cpp
+++ b/src/mutex.cpp
@@ -23,13 +23,13 @@ const adopt_lock_t  adopt_lock = {};
 
 mutex::~mutex()
 {
-    pthread_mutex_destroy(&__m_);
+    __libcpp_mutex_destroy(&__m_);
 }
 
 void
 mutex::lock()
 {
-    int ec = pthread_mutex_lock(&__m_);
+    int ec = __libcpp_mutex_lock(&__m_);
     if (ec)
         __throw_system_error(ec, "mutex lock failed");
 }
@@ -37,13 +37,13 @@ mutex::lock()
 bool
 mutex::try_lock() _NOEXCEPT
 {
-    return pthread_mutex_trylock(&__m_) == 0;
+    return __libcpp_mutex_trylock(&__m_) == 0;
 }
 
 void
 mutex::unlock() _NOEXCEPT
 {
-    int ec = pthread_mutex_unlock(&__m_);
+    int ec = __libcpp_mutex_unlock(&__m_);
     (void)ec;
     assert(ec == 0);
 }
@@ -52,36 +52,14 @@ mutex::unlock() _NOEXCEPT
 
 recursive_mutex::recursive_mutex()
 {
-    pthread_mutexattr_t attr;
-    int ec = pthread_mutexattr_init(&attr);
+    int ec = __libcpp_recursive_mutex_init(&__m_);
     if (ec)
-        goto fail;
-    ec = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
-    if (ec)
-    {
-        pthread_mutexattr_destroy(&attr);
-        goto fail;
-    }
-    ec = pthread_mutex_init(&__m_, &attr);
-    if (ec)
-    {
-        pthread_mutexattr_destroy(&attr);
-        goto fail;
-    }
-    ec = pthread_mutexattr_destroy(&attr);
-    if (ec)
-    {
-        pthread_mutex_destroy(&__m_);
-        goto fail;
-    }
-    return;
-fail:
-    __throw_system_error(ec, "recursive_mutex constructor failed");
+        __throw_system_error(ec, "recursive_mutex constructor failed");
 }
 
 recursive_mutex::~recursive_mutex()
 {
-    int e = pthread_mutex_destroy(&__m_);
+    int e = __libcpp_mutex_destroy(&__m_);
     (void)e;
     assert(e == 0);
 }
@@ -89,7 +67,7 @@ recursive_mutex::~recursive_mutex()
 void
 recursive_mutex::lock()
 {
-    int ec = pthread_mutex_lock(&__m_);
+    int ec = __libcpp_mutex_lock(&__m_);
     if (ec)
         __throw_system_error(ec, "recursive_mutex lock failed");
 }
@@ -97,7 +75,7 @@ recursive_mutex::lock()
 void
 recursive_mutex::unlock() _NOEXCEPT
 {
-    int e = pthread_mutex_unlock(&__m_);
+    int e = __libcpp_mutex_unlock(&__m_);
     (void)e;
     assert(e == 0);
 }
@@ -105,7 +83,7 @@ recursive_mutex::unlock() _NOEXCEPT
 bool
 recursive_mutex::try_lock() _NOEXCEPT
 {
-    return pthread_mutex_trylock(&__m_) == 0;
+    return __libcpp_mutex_trylock(&__m_) == 0;
 }
 
 // timed_mutex
@@ -165,9 +143,9 @@ recursive_timed_mutex::~recursive_timed_mutex()
 void
 recursive_timed_mutex::lock()
 {
-    pthread_t id = pthread_self();
+    __libcpp_thread_id id = __libcpp_thread_get_current_id();
     unique_lock<mutex> lk(__m_);
-    if (pthread_equal(id, __id_))
+    if (__libcpp_thread_id_equal(id, __id_))
     {
         if (__count_ == numeric_limits<size_t>::max())
             __throw_system_error(EAGAIN, "recursive_timed_mutex lock limit reached");
@@ -183,9 +161,9 @@ recursive_timed_mutex::lock()
 bool
 recursive_timed_mutex::try_lock() _NOEXCEPT
 {
-    pthread_t id = pthread_self();
+    __libcpp_thread_id id = __libcpp_thread_get_current_id();
     unique_lock<mutex> lk(__m_, try_to_lock);
-    if (lk.owns_lock() && (__count_ == 0 || pthread_equal(id, __id_)))
+    if (lk.owns_lock() && (__count_ == 0 || __libcpp_thread_id_equal(id, __id_)))
     {
         if (__count_ == numeric_limits<size_t>::max())
             return false;
@@ -217,8 +195,8 @@ recursive_timed_mutex::unlock() _NOEXCEPT
 // keep in sync with:  7741191.
 
 #ifndef _LIBCPP_HAS_NO_THREADS
-static pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
-static pthread_cond_t  cv  = PTHREAD_COND_INITIALIZER;
+static __libcpp_mutex_t mut = _LIBCPP_MUTEX_INITIALIZER;
+static __libcpp_condvar_t cv = _LIBCPP_CONDVAR_INITIALIZER;
 #endif
 
 /// NOTE: Changes to flag are done via relaxed atomic stores
@@ -247,9 +225,9 @@ __call_once(volatile unsigned long& flag, void* arg, void(*func)(void*))
 #endif  // _LIBCPP_NO_EXCEPTIONS
     }
 #else // !_LIBCPP_HAS_NO_THREADS
-    pthread_mutex_lock(&mut);
+    __libcpp_mutex_lock(&mut);
     while (flag == 1)
-        pthread_cond_wait(&cv, &mut);
+        __libcpp_condvar_wait(&cv, &mut);
     if (flag == 0)
     {
 #ifndef _LIBCPP_NO_EXCEPTIONS
@@ -257,26 +235,26 @@ __call_once(volatile unsigned long& flag, void* arg, void(*func)(void*))
         {
 #endif  // _LIBCPP_NO_EXCEPTIONS
             __libcpp_relaxed_store(&flag, 1ul);
-            pthread_mutex_unlock(&mut);
+            __libcpp_mutex_unlock(&mut);
             func(arg);
-            pthread_mutex_lock(&mut);
+            __libcpp_mutex_lock(&mut);
             __libcpp_relaxed_store(&flag, ~0ul);
-            pthread_mutex_unlock(&mut);
-            pthread_cond_broadcast(&cv);
+            __libcpp_mutex_unlock(&mut);
+            __libcpp_condvar_broadcast(&cv);
 #ifndef _LIBCPP_NO_EXCEPTIONS
         }
         catch (...)
         {
-            pthread_mutex_lock(&mut);
+            __libcpp_mutex_lock(&mut);
             __libcpp_relaxed_store(&flag, 0ul);
-            pthread_mutex_unlock(&mut);
-            pthread_cond_broadcast(&cv);
+            __libcpp_mutex_unlock(&mut);
+            __libcpp_condvar_broadcast(&cv);
             throw;
         }
 #endif  // _LIBCPP_NO_EXCEPTIONS
     }
     else
-        pthread_mutex_unlock(&mut);
+        __libcpp_mutex_unlock(&mut);
 #endif // !_LIBCPP_HAS_NO_THREADS
 
 }
diff --git a/src/regex.cpp b/src/regex.cpp
index 17dd6eaa60a7..a7363599d5a5 100644
--- a/src/regex.cpp
+++ b/src/regex.cpp
@@ -69,21 +69,12 @@ regex_error::~regex_error() throw() {}
 
 namespace {
 
-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-
 struct collationnames
 {
     const char* elem_;
     char char_;
 };
 
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif
-
 const collationnames collatenames[] =
 {
     {"A", 0x41},
@@ -199,21 +190,12 @@ const collationnames collatenames[] =
     {"zero", 0x30}
 };
 
-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-
 struct classnames
 {
     const char* elem_;
     regex_traits<char>::char_class_type mask_;
 };
 
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif
-
 const classnames ClassNames[] =
 {
     {"alnum",  ctype_base::alnum},
diff --git a/src/strstream.cpp b/src/strstream.cpp
index ea728138db66..0e2d7ff21bb9 100644
--- a/src/strstream.cpp
+++ b/src/strstream.cpp
@@ -11,6 +11,7 @@
 #include "algorithm"
 #include "climits"
 #include "cstring"
+#include "__debug"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
@@ -167,11 +168,13 @@ strstreambuf::overflow(int_type __c)
             buf = new char[new_size];
         if (buf == nullptr)
             return int_type(EOF);
-        memcpy(buf, eback(), static_cast<size_t>(old_size));
+        if (old_size != 0) {
+            _LIBCPP_ASSERT(eback(), "overflow copying from NULL");
+            memcpy(buf, eback(), static_cast<size_t>(old_size));
+        }
         ptrdiff_t ninp = gptr()  - eback();
         ptrdiff_t einp = egptr() - eback();
         ptrdiff_t nout = pptr()  - pbase();
-        ptrdiff_t eout = epptr() - pbase();
         if (__strmode_ & __allocated)
         {
             if (__pfree_)
@@ -180,7 +183,7 @@ strstreambuf::overflow(int_type __c)
                 delete [] eback();
         }
         setg(buf, buf + ninp, buf + einp);
-        setp(buf + einp, buf + einp + eout);
+        setp(buf + einp, buf + new_size);
         pbump(static_cast<int>(nout));
         __strmode_ |= __allocated;
     }
diff --git a/src/system_error.cpp b/src/system_error.cpp
index 3023e200aa34..87f35ae37f39 100644
--- a/src/system_error.cpp
+++ b/src/system_error.cpp
@@ -13,8 +13,17 @@
 #include "system_error"
 
 #include "include/config_elast.h"
+#include "cerrno"
 #include "cstring"
+#include "cstdio"
+#include "cstdlib"
+#include "cassert"
 #include "string"
+#include "string.h"
+
+#if defined(__ANDROID__)
+#include <android/api-level.h>
+#endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
@@ -46,10 +55,56 @@ error_category::equivalent(const error_code& code, int condition) const _NOEXCEP
     return *this == code.category() && code.value() == condition;
 }
 
+namespace {
+
+//  GLIBC also uses 1024 as the maximum buffer size internally.
+constexpr size_t strerror_buff_size = 1024;
+
+string do_strerror_r(int ev);
+
+#if defined(__linux__) && !defined(_LIBCPP_HAS_MUSL_LIBC)                      \
+    && (!defined(__ANDROID__) || __ANDROID_API__ >= 23)
+// GNU Extended version
+string do_strerror_r(int ev) {
+    char buffer[strerror_buff_size];
+    char* ret = ::strerror_r(ev, buffer, strerror_buff_size);
+    return string(ret);
+}
+#else
+// POSIX version
+string do_strerror_r(int ev) {
+    char buffer[strerror_buff_size];
+    const int old_errno = errno;
+    int ret;
+    if ((ret = ::strerror_r(ev, buffer, strerror_buff_size)) != 0) {
+        // If `ret == -1` then the error is specified using `errno`, otherwise
+        // `ret` represents the error.
+        const int new_errno = ret == -1 ? errno : ret;
+        errno = old_errno;
+        if (new_errno == EINVAL) {
+            std::snprintf(buffer, strerror_buff_size, "Unknown error %d", ev);
+            return string(buffer);
+        } else {
+            assert(new_errno == ERANGE);
+            // FIXME maybe? 'strerror_buff_size' is likely to exceed the
+            // maximum error size so ERANGE shouldn't be returned.
+            std::abort();
+        }
+    }
+    return string(buffer);
+}
+#endif
+
+} // end namespace
+
 string
 __do_message::message(int ev) const
 {
-    return string(strerror(ev));
+#if defined(_LIBCPP_HAS_NO_THREADS)
+    return string(::strerror(ev));
+#else
+    return do_strerror_r(ev);
+#endif
 }
 
 class _LIBCPP_HIDDEN __generic_error_category
diff --git a/src/thread.cpp b/src/thread.cpp
index bd27f2878383..467402b6b423 100644
--- a/src/thread.cpp
+++ b/src/thread.cpp
@@ -16,10 +16,15 @@
 #include "future"
 #include "limits"
 #include <sys/types.h>
-#if !defined(_WIN32)
-# if !defined(__sun__) && !defined(__linux__) && !defined(_AIX) && !defined(__native_client__) && !defined(__CloudABI__)
+
+#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
+# include <sys/param.h>
+# if defined(BSD)
 #   include <sys/sysctl.h>
-# endif // !defined(__sun__) && !defined(__linux__) && !defined(_AIX) && !defined(__native_client__) && !defined(__CloudABI__)
+# endif // defined(BSD)
+#endif // defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
+
+#if !defined(_WIN32)
 # include <unistd.h>
 #endif // !_WIN32
 
@@ -41,14 +46,17 @@ thread::~thread()
 void
 thread::join()
 {
-    int ec = pthread_join(__t_, 0);
+    int ec = EINVAL;
+    if (__t_ != 0)
+    {
+        ec = __libcpp_thread_join(&__t_);
+        if (ec == 0)
+            __t_ = 0;
+    }
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (ec)
         throw system_error(error_code(ec, system_category()), "thread::join failed");
-#else
-    (void)ec;
 #endif  // _LIBCPP_NO_EXCEPTIONS
-    __t_ = 0;
 }
 
 void
@@ -57,7 +65,7 @@ thread::detach()
     int ec = EINVAL;
     if (__t_ != 0)
     {
-        ec = pthread_detach(__t_);
+        ec = __libcpp_thread_detach(&__t_);
         if (ec == 0)
             __t_ = 0;
     }
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index b67b3b43f83e..d47a9e003fc0 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -10,11 +10,16 @@ set(LIBCXX_LIT_VARIANT "libcxx" CACHE STRING
     "Configuration variant to use for LIT.")
 
 pythonize_bool(LIBCXX_ENABLE_EXCEPTIONS)
+pythonize_bool(LIBCXX_ENABLE_EXPERIMENTAL_LIBRARY)
+pythonize_bool(LIBCXX_ENABLE_FILESYSTEM)
 pythonize_bool(LIBCXX_ENABLE_RTTI)
 pythonize_bool(LIBCXX_ENABLE_SHARED)
 pythonize_bool(LIBCXX_BUILD_32_BITS)
 pythonize_bool(LIBCXX_GENERATE_COVERAGE)
+pythonize_bool(LIBCXXABI_ENABLE_SHARED)
 pythonize_bool(LIBCXXABI_USE_LLVM_UNWINDER)
+pythonize_bool(LIBCXX_HAS_ATOMIC_LIB)
+pythonize_bool(LIBCXX_HAVE_CXX_ATOMICS_WITH_LIB)
 
 # The tests shouldn't link to any ABI library when it has been linked into
 # libc++ statically or via a linker script.
@@ -22,6 +27,13 @@ if (LIBCXX_ENABLE_STATIC_ABI_LIBRARY OR LIBCXX_ENABLE_ABI_LINKER_SCRIPT)
   set(LIBCXX_CXX_ABI_LIBNAME "none")
 endif()
 
+# By default, for non-standalone builds, libcxx and libcxxabi share a library
+# directory.
+if (NOT LIBCXX_CXX_ABI_LIBRARY_PATH)
+  set(LIBCXX_CXX_ABI_LIBRARY_PATH "${LIBCXX_LIBRARY_DIR}" CACHE PATH
+      "The path to libc++abi library.")
+endif()
+
 set(LIBCXX_TARGET_INFO "libcxx.test.target_info.LocalTI" CACHE STRING
     "TargetInfo to use when setting up test environment.")
 set(LIBCXX_EXECUTOR "None" CACHE STRING
@@ -34,15 +46,19 @@ configure_file(
   ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg
   @ONLY)
 
+if (LIBCXX_ENABLE_EXPERIMENTAL_LIBRARY)
+  set(experimental_dep cxx_experimental)
+endif()
+
 add_lit_testsuite(check-libcxx
   "Running libcxx tests"
   ${CMAKE_CURRENT_BINARY_DIR}
-  DEPENDS cxx)
+  DEPENDS cxx ${experimental_dep})
 
 if (LIBCXX_GENERATE_COVERAGE)
   include(CodeCoverage)
   set(output_dir "${CMAKE_CURRENT_BINARY_DIR}/coverage")
-  set(capture_dirs "${LIBCXX_LIB_CMAKEFILES_DIR}/cxx.dir/;${CMAKE_CURRENT_BINARY_DIR}")
+  set(capture_dirs "${LIBCXX_LIB_CMAKEFILES_DIR}/cxx.dir/;${LIBCXX_LIB_CMAKEFILES_DIR}/cxx_experimental.dir/;${CMAKE_CURRENT_BINARY_DIR}")
   set(extract_dirs "${LIBCXX_SOURCE_DIR}/include;${LIBCXX_SOURCE_DIR}/src")
   setup_lcov_test_target_coverage("cxx" "${output_dir}" "${capture_dirs}" "${extract_dirs}")
 endif()
diff --git a/test/std/algorithms/version.pass.cpp b/test/libcxx/algorithms/version.pass.cpp
index 20f0637e641b..20f0637e641b 100644
--- a/test/std/algorithms/version.pass.cpp
+++ b/test/libcxx/algorithms/version.pass.cpp
diff --git a/test/std/atomics/atomics.flag/init03.pass.cpp b/test/libcxx/atomics/atomics.flag/init_bool.pass.cpp
index 0910bc5ceccb..d7b172cd1212 100644
--- a/test/std/atomics/atomics.flag/init03.pass.cpp
+++ b/test/libcxx/atomics/atomics.flag/init_bool.pass.cpp
@@ -20,6 +20,12 @@
 
 int main()
 {
-    std::atomic_flag f(false);
-    assert(f.test_and_set() == 0);
+    {
+        std::atomic_flag f(false);
+        assert(f.test_and_set() == 0);
+    }
+    {
+        std::atomic_flag f(true);
+        assert(f.test_and_set() == 1);
+    }
 }
diff --git a/test/std/atomics/version.pass.cpp b/test/libcxx/atomics/version.pass.cpp
index fae2736d229f..fae2736d229f 100644
--- a/test/std/atomics/version.pass.cpp
+++ b/test/libcxx/atomics/version.pass.cpp
diff --git a/test/libcxx/compiler.py b/test/libcxx/compiler.py
index 7dfb13abbd41..17e6cf441ec1 100644
--- a/test/libcxx/compiler.py
+++ b/test/libcxx/compiler.py
@@ -47,9 +47,10 @@ class CXXCompiler(object):
         self.type = compiler_type
         self.version = (major_ver, minor_ver, patchlevel)
 
-    def _basicCmd(self, source_files, out, is_link=False, input_is_cxx=False):
+    def _basicCmd(self, source_files, out, is_link=False, input_is_cxx=False,
+                  disable_ccache=False):
         cmd = []
-        if self.use_ccache and not is_link:
+        if self.use_ccache and not disable_ccache and not is_link:
             cmd += ['ccache']
         cmd += [self.path]
         if out is not None:
@@ -65,12 +66,15 @@ class CXXCompiler(object):
         return cmd
 
     def preprocessCmd(self, source_files, out=None, flags=[]):
-        cmd = self._basicCmd(source_files, out, input_is_cxx=True) + ['-E']
+        cmd = self._basicCmd(source_files, out, input_is_cxx=True,
+                             disable_ccache=True) + ['-E']
         cmd += self.flags + self.compile_flags + flags
         return cmd
 
-    def compileCmd(self, source_files, out=None, flags=[]):
-        cmd = self._basicCmd(source_files, out, input_is_cxx=True) + ['-c']
+    def compileCmd(self, source_files, out=None, flags=[],
+                   disable_ccache=False):
+        cmd = self._basicCmd(source_files, out, input_is_cxx=True,
+                             disable_ccache=disable_ccache) + ['-c']
         cmd += self.flags + self.compile_flags + flags
         return cmd
 
@@ -89,8 +93,10 @@ class CXXCompiler(object):
         out, err, rc = lit.util.executeCommand(cmd, env=env, cwd=cwd)
         return cmd, out, err, rc
 
-    def compile(self, source_files, out=None, flags=[], env=None, cwd=None):
-        cmd = self.compileCmd(source_files, out, flags)
+    def compile(self, source_files, out=None, flags=[], env=None, cwd=None,
+                disable_ccache=False):
+        cmd = self.compileCmd(source_files, out, flags,
+                              disable_ccache=disable_ccache)
         out, err, rc = lit.util.executeCommand(cmd, env=env, cwd=cwd)
         return cmd, out, err, rc
 
@@ -106,7 +112,8 @@ class CXXCompiler(object):
         return cmd, out, err, rc
 
     def compileLinkTwoSteps(self, source_file, out=None, object_file=None,
-                            flags=[], env=None, cwd=None):
+                            flags=[], env=None, cwd=None,
+                            disable_ccache=False):
         if not isinstance(source_file, str):
             raise TypeError('This function only accepts a single input file')
         if object_file is None:
@@ -117,7 +124,8 @@ class CXXCompiler(object):
             with_fn = lambda: libcxx.util.nullContext(object_file)
         with with_fn() as object_file:
             cc_cmd, cc_stdout, cc_stderr, rc = self.compile(
-                    source_file, object_file, flags=flags, env=env, cwd=cwd)
+                    source_file, object_file, flags=flags, env=env, cwd=cwd,
+                    disable_ccache=disable_ccache)
             if rc != 0:
                 return cc_cmd, cc_stdout, cc_stderr, rc
 
diff --git a/test/std/containers/associative/map/version.pass.cpp b/test/libcxx/containers/associative/map/version.pass.cpp
index b2e3fa43e787..b2e3fa43e787 100644
--- a/test/std/containers/associative/map/version.pass.cpp
+++ b/test/libcxx/containers/associative/map/version.pass.cpp
diff --git a/test/std/containers/associative/set/version.pass.cpp b/test/libcxx/containers/associative/set/version.pass.cpp
index c3c4d926e5c3..c3c4d926e5c3 100644
--- a/test/std/containers/associative/set/version.pass.cpp
+++ b/test/libcxx/containers/associative/set/version.pass.cpp
diff --git a/test/std/containers/associative/tree_balance_after_insert.pass.cpp b/test/libcxx/containers/associative/tree_balance_after_insert.pass.cpp
index b0a3e74cab0a..300c1e9a4915 100644
--- a/test/std/containers/associative/tree_balance_after_insert.pass.cpp
+++ b/test/libcxx/containers/associative/tree_balance_after_insert.pass.cpp
@@ -24,6 +24,9 @@ struct Node
     Node* __parent_;
     bool __is_black_;
 
+    Node* __parent_unsafe() const { return __parent_; }
+    void __set_parent(Node* x) { __parent_ = x;}
+
     Node() : __left_(), __right_(), __parent_(), __is_black_() {}
 };
 
diff --git a/test/libcxx/containers/associative/tree_key_value_traits.pass.cpp b/test/libcxx/containers/associative/tree_key_value_traits.pass.cpp
new file mode 100644
index 000000000000..0befd749a50c
--- /dev/null
+++ b/test/libcxx/containers/associative/tree_key_value_traits.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.
+//
+//===----------------------------------------------------------------------===//
+
+#include <__tree>
+#include <map>
+#include <set>
+#include <type_traits>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+void testKeyValueTrait() {
+  {
+    typedef int Tp;
+    typedef std::__tree_key_value_types<Tp> Traits;
+    static_assert((std::is_same<Traits::key_type, int>::value), "");
+    static_assert((std::is_same<Traits::__node_value_type, Tp>::value), "");
+    static_assert((std::is_same<Traits::__container_value_type, Tp>::value), "");
+    static_assert(Traits::__is_map == false, "");
+  }
+  {
+    typedef std::pair<int, int> Tp;
+    typedef std::__tree_key_value_types<Tp> Traits;
+    static_assert((std::is_same<Traits::key_type, Tp>::value), "");
+    static_assert((std::is_same<Traits::__node_value_type, Tp>::value), "");
+    static_assert((std::is_same<Traits::__container_value_type, Tp>::value), "");
+    static_assert(Traits::__is_map == false, "");
+  }
+  {
+    typedef std::pair<const int, int> Tp;
+    typedef std::__tree_key_value_types<Tp> Traits;
+    static_assert((std::is_same<Traits::key_type, Tp>::value), "");
+    static_assert((std::is_same<Traits::__node_value_type, Tp>::value), "");
+    static_assert((std::is_same<Traits::__container_value_type, Tp>::value), "");
+    static_assert(Traits::__is_map == false, "");
+  }
+  {
+    typedef std::__value_type<int, int> Tp;
+    typedef std::__tree_key_value_types<Tp> Traits;
+    static_assert((std::is_same<Traits::key_type, int>::value), "");
+    static_assert((std::is_same<Traits::mapped_type, int>::value), "");
+    static_assert((std::is_same<Traits::__node_value_type, Tp>::value), "");
+    static_assert((std::is_same<Traits::__container_value_type,
+                               std::pair<const int, int> >::value), "");
+    static_assert((std::is_same<Traits::__map_value_type,
+                               std::pair<const int, int> >::value), "");
+    static_assert(Traits::__is_map == true, "");
+  }
+}
+
+int main() {
+  testKeyValueTrait();
+}
diff --git a/test/std/containers/associative/tree_left_rotate.pass.cpp b/test/libcxx/containers/associative/tree_left_rotate.pass.cpp
index 774cbc687985..2720b448bdd4 100644
--- a/test/std/containers/associative/tree_left_rotate.pass.cpp
+++ b/test/libcxx/containers/associative/tree_left_rotate.pass.cpp
@@ -23,6 +23,9 @@ struct Node
     Node* __right_;
     Node* __parent_;
 
+    Node* __parent_unsafe() const { return __parent_; }
+    void __set_parent(Node* x) { __parent_ = x;}
+
     Node() : __left_(), __right_(), __parent_() {}
 };
 
diff --git a/test/std/containers/associative/tree_remove.pass.cpp b/test/libcxx/containers/associative/tree_remove.pass.cpp
index fb14bd929e91..fa0b7d4a1311 100644
--- a/test/std/containers/associative/tree_remove.pass.cpp
+++ b/test/libcxx/containers/associative/tree_remove.pass.cpp
@@ -24,6 +24,9 @@ struct Node
     Node* __parent_;
     bool __is_black_;
 
+    Node* __parent_unsafe() const { return __parent_; }
+    void __set_parent(Node* x) { __parent_ = x;}
+
     Node() : __left_(), __right_(), __parent_(), __is_black_() {}
 };
 
diff --git a/test/std/containers/associative/tree_right_rotate.pass.cpp b/test/libcxx/containers/associative/tree_right_rotate.pass.cpp
index 06ec7b889452..9355a46b4e2b 100644
--- a/test/std/containers/associative/tree_right_rotate.pass.cpp
+++ b/test/libcxx/containers/associative/tree_right_rotate.pass.cpp
@@ -23,6 +23,9 @@ struct Node
     Node* __right_;
     Node* __parent_;
 
+    Node* __parent_unsafe() const { return __parent_; }
+    void __set_parent(Node* x) { __parent_ = x;}
+
     Node() : __left_(), __right_(), __parent_() {}
 };
 
diff --git a/test/std/containers/container.adaptors/queue/version.pass.cpp b/test/libcxx/containers/container.adaptors/queue/version.pass.cpp
index 35b94b33c517..35b94b33c517 100644
--- a/test/std/containers/container.adaptors/queue/version.pass.cpp
+++ b/test/libcxx/containers/container.adaptors/queue/version.pass.cpp
diff --git a/test/std/containers/container.adaptors/stack/version.pass.cpp b/test/libcxx/containers/container.adaptors/stack/version.pass.cpp
index 339d0f4dda8f..339d0f4dda8f 100644
--- a/test/std/containers/container.adaptors/stack/version.pass.cpp
+++ b/test/libcxx/containers/container.adaptors/stack/version.pass.cpp
diff --git a/test/libcxx/containers/gnu_cxx/hash_map.pass.cpp b/test/libcxx/containers/gnu_cxx/hash_map.pass.cpp
new file mode 100644
index 000000000000..0d9115d0f693
--- /dev/null
+++ b/test/libcxx/containers/gnu_cxx/hash_map.pass.cpp
@@ -0,0 +1,26 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// Prevent emission of the deprecated warning.
+#ifdef __clang__
+#pragma clang diagnostic ignored "-W#warnings"
+#endif
+
+#include <ext/hash_map>
+
+namespace __gnu_cxx {
+template class hash_map<int, int>;
+}
+
+int main() {
+  typedef __gnu_cxx::hash_map<int, int> Map;
+  Map m;
+  Map m2(m);
+  ((void)m2);
+}
diff --git a/test/libcxx/containers/gnu_cxx/hash_set.pass.cpp b/test/libcxx/containers/gnu_cxx/hash_set.pass.cpp
new file mode 100644
index 000000000000..5fd4bde66e0a
--- /dev/null
+++ b/test/libcxx/containers/gnu_cxx/hash_set.pass.cpp
@@ -0,0 +1,26 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// Prevent emission of the deprecated warning.
+#ifdef __clang__
+#pragma clang diagnostic ignored "-W#warnings"
+#endif
+
+#include <ext/hash_set>
+
+namespace __gnu_cxx {
+template class hash_set<int>;
+}
+
+int main() {
+  typedef __gnu_cxx::hash_set<int> Set;
+  Set s;
+  Set s2(s);
+  ((void)s2);
+}
diff --git a/test/std/containers/sequences/array/version.pass.cpp b/test/libcxx/containers/sequences/array/version.pass.cpp
index b89a8dd8cca3..b89a8dd8cca3 100644
--- a/test/std/containers/sequences/array/version.pass.cpp
+++ b/test/libcxx/containers/sequences/array/version.pass.cpp
diff --git a/test/std/containers/sequences/deque/version.pass.cpp b/test/libcxx/containers/sequences/deque/version.pass.cpp
index 22e663d9bc22..22e663d9bc22 100644
--- a/test/std/containers/sequences/deque/version.pass.cpp
+++ b/test/libcxx/containers/sequences/deque/version.pass.cpp
diff --git a/test/std/containers/sequences/forwardlist/version.pass.cpp b/test/libcxx/containers/sequences/forwardlist/version.pass.cpp
index 918c8dd5d73c..918c8dd5d73c 100644
--- a/test/std/containers/sequences/forwardlist/version.pass.cpp
+++ b/test/libcxx/containers/sequences/forwardlist/version.pass.cpp
diff --git a/test/std/containers/sequences/list/db_back.pass.cpp b/test/libcxx/containers/sequences/list/db_back.pass.cpp
index b16c0e90701e..96dfd2d8d2ec 100644
--- a/test/std/containers/sequences/list/db_back.pass.cpp
+++ b/test/libcxx/containers/sequences/list/db_back.pass.cpp
@@ -11,8 +11,7 @@
 
 // Call back() on empty container.
 
-#if _LIBCPP_DEBUG >= 1
-
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <list>
@@ -21,11 +20,8 @@
 #include <exception>
 #include <cstdlib>
 
-#include "min_allocator.h"
-
 int main()
 {
-    {
     typedef int T;
     typedef std::list<T> C;
     C c(1);
@@ -33,24 +29,4 @@ int main()
     c.clear();
     assert(c.back() == 0);
     assert(false);
-    }
-#if __cplusplus >= 201103L
-    {
-    typedef int T;
-    typedef std::list<T, min_allocator<T>> C;
-    C c(1);
-    assert(c.back() == 0);
-    c.clear();
-    assert(c.back() == 0);
-    assert(false);
-    }
-#endif
 }
-
-#else
-
-int main()
-{
-}
-
-#endif
diff --git a/test/std/containers/sequences/list/db_cback.pass.cpp b/test/libcxx/containers/sequences/list/db_cback.pass.cpp
index ba3977e16f48..1e25307c4602 100644
--- a/test/std/containers/sequences/list/db_cback.pass.cpp
+++ b/test/libcxx/containers/sequences/list/db_cback.pass.cpp
@@ -11,8 +11,7 @@
 
 // Call back() on empty const container.
 
-#if _LIBCPP_DEBUG >= 1
-
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <list>
@@ -21,32 +20,11 @@
 #include <exception>
 #include <cstdlib>
 
-#include "min_allocator.h"
-
 int main()
 {
-    {
     typedef int T;
     typedef std::list<T> C;
     const C c;
     assert(c.back() == 0);
     assert(false);
-    }
-#if __cplusplus >= 201103L
-    {
-    typedef int T;
-    typedef std::list<T, min_allocator<T>> C;
-    const C c;
-    assert(c.back() == 0);
-    assert(false);
-    }
-#endif
 }
-
-#else
-
-int main()
-{
-}
-
-#endif
diff --git a/test/std/containers/sequences/list/db_cfront.pass.cpp b/test/libcxx/containers/sequences/list/db_cfront.pass.cpp
index d42290c43c08..9501ce193138 100644
--- a/test/std/containers/sequences/list/db_cfront.pass.cpp
+++ b/test/libcxx/containers/sequences/list/db_cfront.pass.cpp
@@ -11,8 +11,7 @@
 
 // Call front() on empty const container.
 
-#if _LIBCPP_DEBUG >= 1
-
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <list>
@@ -21,32 +20,11 @@
 #include <exception>
 #include <cstdlib>
 
-#include "min_allocator.h"
-
 int main()
 {
-    {
     typedef int T;
     typedef std::list<T> C;
     const C c;
     assert(c.front() == 0);
     assert(false);
-    }
-#if __cplusplus >= 201103L
-    {
-    typedef int T;
-    typedef std::list<T, min_allocator<T>> C;
-    const C c;
-    assert(c.front() == 0);
-    assert(false);
-    }
-#endif
 }
-
-#else
-
-int main()
-{
-}
-
-#endif
diff --git a/test/std/containers/sequences/list/db_front.pass.cpp b/test/libcxx/containers/sequences/list/db_front.pass.cpp
index 037b16035c66..fc02895a8912 100644
--- a/test/std/containers/sequences/list/db_front.pass.cpp
+++ b/test/libcxx/containers/sequences/list/db_front.pass.cpp
@@ -11,8 +11,7 @@
 
 // Call front() on empty container.
 
-#if _LIBCPP_DEBUG >= 1
-
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <list>
@@ -21,11 +20,8 @@
 #include <exception>
 #include <cstdlib>
 
-#include "min_allocator.h"
-
 int main()
 {
-    {
     typedef int T;
     typedef std::list<T> C;
     C c(1);
@@ -33,24 +29,4 @@ int main()
     c.clear();
     assert(c.front() == 0);
     assert(false);
-    }
-#if __cplusplus >= 201103L
-    {
-    typedef int T;
-    typedef std::list<T, min_allocator<T>> C;
-    C c(1);
-    assert(c.front() == 0);
-    c.clear();
-    assert(c.front() == 0);
-    assert(false);
-    }
-#endif
 }
-
-#else
-
-int main()
-{
-}
-
-#endif
diff --git a/test/std/containers/sequences/list/db_iterators_6.pass.cpp b/test/libcxx/containers/sequences/list/db_iterators_6.pass.cpp
index a5b8020b3733..3f0fd015e9a4 100644
--- a/test/std/containers/sequences/list/db_iterators_6.pass.cpp
+++ b/test/libcxx/containers/sequences/list/db_iterators_6.pass.cpp
@@ -11,8 +11,7 @@
 
 // Decrement iterator prior to begin.
 
-#if _LIBCPP_DEBUG >= 1
-
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <list>
@@ -21,11 +20,8 @@
 #include <exception>
 #include <cstdlib>
 
-#include "min_allocator.h"
-
 int main()
 {
-    {
     typedef int T;
     typedef std::list<T> C;
     C c(1);
@@ -34,25 +30,4 @@ int main()
     assert(i == c.begin());
     --i;
     assert(false);
-    }
-#if __cplusplus >= 201103L
-    {
-    typedef int T;
-    typedef std::list<T, min_allocator<T>> C;
-    C c(1);
-    C::iterator i = c.end();
-    --i;
-    assert(i == c.begin());
-    --i;
-    assert(false);
-    }
-#endif
 }
-
-#else
-
-int main()
-{
-}
-
-#endif
diff --git a/test/std/containers/sequences/list/db_iterators_7.pass.cpp b/test/libcxx/containers/sequences/list/db_iterators_7.pass.cpp
index 76a491b1184d..bc2b7f4e1da2 100644
--- a/test/std/containers/sequences/list/db_iterators_7.pass.cpp
+++ b/test/libcxx/containers/sequences/list/db_iterators_7.pass.cpp
@@ -11,8 +11,7 @@
 
 // Increment iterator past end.
 
-#if _LIBCPP_DEBUG >= 1
-
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <list>
@@ -21,11 +20,8 @@
 #include <exception>
 #include <cstdlib>
 
-#include "min_allocator.h"
-
 int main()
 {
-    {
     typedef int T;
     typedef std::list<T> C;
     C c(1);
@@ -34,25 +30,4 @@ int main()
     assert(i == c.end());
     ++i;
     assert(false);
-    }
-#if __cplusplus >= 201103L
-    {
-    typedef int T;
-    typedef std::list<T, min_allocator<T>> C;
-    C c(1);
-    C::iterator i = c.begin();
-    ++i;
-    assert(i == c.end());
-    ++i;
-    assert(false);
-    }
-#endif
 }
-
-#else
-
-int main()
-{
-}
-
-#endif
diff --git a/test/std/containers/sequences/list/db_iterators_8.pass.cpp b/test/libcxx/containers/sequences/list/db_iterators_8.pass.cpp
index 1d1ee23a393a..08c10d34a01e 100644
--- a/test/std/containers/sequences/list/db_iterators_8.pass.cpp
+++ b/test/libcxx/containers/sequences/list/db_iterators_8.pass.cpp
@@ -11,8 +11,7 @@
 
 // Dereference non-dereferenceable iterator.
 
-#if _LIBCPP_DEBUG >= 1
-
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <list>
@@ -21,34 +20,12 @@
 #include <exception>
 #include <cstdlib>
 
-#include "min_allocator.h"
-
 int main()
 {
-    {
     typedef int T;
     typedef std::list<T> C;
     C c(1);
     C::iterator i = c.end();
     T j = *i;
     assert(false);
-    }
-#if __cplusplus >= 201103L
-    {
-    typedef int T;
-    typedef std::list<T, min_allocator<T>> C;
-    C c(1);
-    C::iterator i = c.end();
-    T j = *i;
-    assert(false);
-    }
-#endif
 }
-
-#else
-
-int main()
-{
-}
-
-#endif
diff --git a/test/std/containers/sequences/list/db_iterators_9.pass.cpp b/test/libcxx/containers/sequences/list/db_iterators_9.pass.cpp
index d02fcd6e4497..e2b95d8b1664 100644
--- a/test/std/containers/sequences/list/db_iterators_9.pass.cpp
+++ b/test/libcxx/containers/sequences/list/db_iterators_9.pass.cpp
@@ -7,12 +7,14 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+// UNSUPPORTED: libcpp-no-exceptions
+
 // <list>
 
 // Operations on "NULL" iterators
 
-#if _LIBCPP_DEBUG >= 1
-
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) do { if (!x) throw 1; } while(0)
 
 #include <list>
@@ -25,7 +27,6 @@ struct S { int val; };
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     {
     unsigned lib_asserts;
 
@@ -33,7 +34,7 @@ int main()
     typedef std::list<T> C;
     C::iterator i{};
     C::const_iterator ci{};
-    
+
     lib_asserts = 0;
     try { ++i; }  catch (int) { ++lib_asserts; }
     try { i++; }  catch (int) { ++lib_asserts; }
@@ -55,13 +56,4 @@ int main()
     try { (void) ci->val; } catch (int) { ++lib_asserts; }
     assert(lib_asserts == 4);
     }
-#endif
 }
-
-#else
-
-int main()
-{
-}
-
-#endif
diff --git a/test/libcxx/containers/sequences/list/list.cons/db_copy.pass.cpp b/test/libcxx/containers/sequences/list/list.cons/db_copy.pass.cpp
new file mode 100644
index 000000000000..c84960f37686
--- /dev/null
+++ b/test/libcxx/containers/sequences/list/list.cons/db_copy.pass.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <list>
+
+// list(list&& c);
+
+#define _LIBCPP_DEBUG 1
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+
+#include <list>
+#include <cstdlib>
+#include <cassert>
+
+int main()
+{
+    std::list<int> l1;
+    l1.push_back(1); l1.push_back(2); l1.push_back(3);
+    std::list<int>::iterator i = l1.begin();
+    std::list<int> l2 = l1;
+    l2.erase(i);
+    assert(false);
+}
diff --git a/test/libcxx/containers/sequences/list/list.cons/db_move.pass.cpp b/test/libcxx/containers/sequences/list/list.cons/db_move.pass.cpp
new file mode 100644
index 000000000000..dd424e89e756
--- /dev/null
+++ b/test/libcxx/containers/sequences/list/list.cons/db_move.pass.cpp
@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <list>
+
+// list(list&& c);
+
+#define _LIBCPP_DEBUG 1
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(1))
+
+#include <list>
+#include <cstdlib>
+#include <cassert>
+#include "MoveOnly.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+int main()
+{
+    std::list<int> l1 = {1, 2, 3};
+    std::list<int>::iterator i = l1.begin();
+    std::list<int> l2 = std::move(l1);
+    assert(*l2.erase(i) == 2);
+}
diff --git a/test/libcxx/containers/sequences/list/list.modifiers/emplace_db1.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/emplace_db1.pass.cpp
new file mode 100644
index 000000000000..1d64f9bd9e27
--- /dev/null
+++ b/test/libcxx/containers/sequences/list/list.modifiers/emplace_db1.pass.cpp
@@ -0,0 +1,44 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <list>
+
+// template <class... Args> void emplace(const_iterator p, Args&&... args);
+
+#define _LIBCPP_DEBUG 1
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+
+#include <list>
+#include <cstdlib>
+#include <cassert>
+
+class A
+{
+    int i_;
+    double d_;
+
+    A(const A&);
+    A& operator=(const A&);
+public:
+    A(int i, double d)
+        : i_(i), d_(d) {}
+
+    int geti() const {return i_;}
+    double getd() const {return d_;}
+};
+
+int main()
+{
+    std::list<A> c1;
+    std::list<A> c2;
+    std::list<A>::iterator i = c1.emplace(c2.cbegin(), 2, 3.5);
+    assert(false);
+}
diff --git a/test/std/containers/sequences/list/list.modifiers/erase_iter_db1.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_db1.pass.cpp
index 18c15eb02c85..ec5de0264cb4 100644
--- a/test/std/containers/sequences/list/list.modifiers/erase_iter_db1.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_db1.pass.cpp
@@ -11,41 +11,18 @@
 
 // Call erase(const_iterator position) with end()
 
-#if _LIBCPP_DEBUG >= 1
-
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <list>
 #include <cassert>
 #include <cstdlib>
-#include <exception>
-
-#include "min_allocator.h"
 
 int main()
 {
-    {
     int a1[] = {1, 2, 3};
     std::list<int> l1(a1, a1+3);
     std::list<int>::const_iterator i = l1.end();
     l1.erase(i);
     assert(false);
-    }
-#if __cplusplus >= 201103L
-    {
-    int a1[] = {1, 2, 3};
-    std::list<int, min_allocator<int>> l1(a1, a1+3);
-    std::list<int, min_allocator<int>>::const_iterator i = l1.end();
-    l1.erase(i);
-    assert(false);
-    }
-#endif
 }
-
-#else
-
-int main()
-{
-}
-
-#endif
diff --git a/test/std/containers/sequences/list/list.modifiers/erase_iter_db2.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_db2.pass.cpp
index 61ff8409c964..833e2b54dfaf 100644
--- a/test/std/containers/sequences/list/list.modifiers/erase_iter_db2.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_db2.pass.cpp
@@ -11,43 +11,19 @@
 
 // Call erase(const_iterator position) with iterator from another container
 
-#if _LIBCPP_DEBUG >= 1
-
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <list>
 #include <cassert>
 #include <cstdlib>
-#include <exception>
-
-#include "min_allocator.h"
 
 int main()
 {
-    {
     int a1[] = {1, 2, 3};
     std::list<int> l1(a1, a1+3);
     std::list<int> l2(a1, a1+3);
     std::list<int>::const_iterator i = l2.begin();
     l1.erase(i);
     assert(false);
-    }
-#if __cplusplus >= 201103L
-    {
-    int a1[] = {1, 2, 3};
-    std::list<int, min_allocator<int>> l1(a1, a1+3);
-    std::list<int, min_allocator<int>> l2(a1, a1+3);
-    std::list<int, min_allocator<int>>::const_iterator i = l2.begin();
-    l1.erase(i);
-    assert(false);
-    }
-#endif
 }
-
-#else
-
-int main()
-{
-}
-
-#endif
diff --git a/test/std/containers/sequences/list/list.modifiers/erase_iter_iter_db1.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db1.pass.cpp
index 71ad497e7d97..eef7a98e739a 100644
--- a/test/std/containers/sequences/list/list.modifiers/erase_iter_iter_db1.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db1.pass.cpp
@@ -11,41 +11,19 @@
 
 // Call erase(const_iterator first, const_iterator last); with first iterator from another container
 
-#if _LIBCPP_DEBUG >= 1
-
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <list>
 #include <cassert>
-#include <exception>
 #include <cstdlib>
 
-#include "min_allocator.h"
-
 int main()
 {
-    {
     int a1[] = {1, 2, 3};
     std::list<int> l1(a1, a1+3);
     std::list<int> l2(a1, a1+3);
     std::list<int>::iterator i = l1.erase(l2.cbegin(), next(l1.cbegin()));
     assert(false);
-    }
-#if __cplusplus >= 201103L
-    {
-    int a1[] = {1, 2, 3};
-    std::list<int, min_allocator<int>> l1(a1, a1+3);
-    std::list<int, min_allocator<int>> l2(a1, a1+3);
-    std::list<int, min_allocator<int>>::iterator i = l1.erase(l2.cbegin(), next(l1.cbegin()));
-    assert(false);
-    }
-#endif
-}
-
-#else
-
-int main()
-{
 }
 
-#endif
diff --git a/test/std/containers/sequences/list/list.modifiers/erase_iter_iter_db2.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db2.pass.cpp
index db76b4de4865..0dd03dc50da1 100644
--- a/test/std/containers/sequences/list/list.modifiers/erase_iter_iter_db2.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db2.pass.cpp
@@ -11,41 +11,18 @@
 
 // Call erase(const_iterator first, const_iterator last); with second iterator from another container
 
-#if _LIBCPP_DEBUG >= 1
-
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <list>
 #include <cassert>
-#include <exception>
 #include <cstdlib>
 
-#include "min_allocator.h"
-
 int main()
 {
-    {
     int a1[] = {1, 2, 3};
     std::list<int> l1(a1, a1+3);
     std::list<int> l2(a1, a1+3);
     std::list<int>::iterator i = l1.erase(l1.cbegin(), next(l2.cbegin()));
     assert(false);
-    }
-#if __cplusplus >= 201103L
-    {
-    int a1[] = {1, 2, 3};
-    std::list<int, min_allocator<int>> l1(a1, a1+3);
-    std::list<int, min_allocator<int>> l2(a1, a1+3);
-    std::list<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), next(l2.cbegin()));
-    assert(false);
-    }
-#endif
-}
-
-#else
-
-int main()
-{
 }
-
-#endif
diff --git a/test/std/containers/sequences/list/list.modifiers/erase_iter_iter_db3.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db3.pass.cpp
index 25c5c6147a01..22273a89f1e5 100644
--- a/test/std/containers/sequences/list/list.modifiers/erase_iter_iter_db3.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db3.pass.cpp
@@ -11,41 +11,18 @@
 
 // Call erase(const_iterator first, const_iterator last); with both iterators from another container
 
-#if _LIBCPP_DEBUG >= 1
-
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <list>
 #include <cassert>
-#include <exception>
 #include <cstdlib>
 
-#include "min_allocator.h"
-
 int main()
 {
-    {
     int a1[] = {1, 2, 3};
     std::list<int> l1(a1, a1+3);
     std::list<int> l2(a1, a1+3);
     std::list<int>::iterator i = l1.erase(l2.cbegin(), next(l2.cbegin()));
     assert(false);
-    }
-#if __cplusplus >= 201103L
-    {
-    int a1[] = {1, 2, 3};
-    std::list<int, min_allocator<int>> l1(a1, a1+3);
-    std::list<int, min_allocator<int>> l2(a1, a1+3);
-    std::list<int, min_allocator<int>>::iterator i = l1.erase(l2.cbegin(), next(l2.cbegin()));
-    assert(false);
-    }
-#endif
-}
-
-#else
-
-int main()
-{
 }
-
-#endif
diff --git a/test/std/containers/sequences/list/list.modifiers/erase_iter_iter_db4.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db4.pass.cpp
index 35a4ceb4848a..d1e03c8ac710 100644
--- a/test/std/containers/sequences/list/list.modifiers/erase_iter_iter_db4.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db4.pass.cpp
@@ -11,39 +11,17 @@
 
 // Call erase(const_iterator first, const_iterator last); with a bad range
 
-#if _LIBCPP_DEBUG >= 1
-
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <list>
 #include <cassert>
-#include <exception>
 #include <cstdlib>
 
-#include "min_allocator.h"
-
 int main()
 {
-    {
     int a1[] = {1, 2, 3};
     std::list<int> l1(a1, a1+3);
     std::list<int>::iterator i = l1.erase(next(l1.cbegin()), l1.cbegin());
     assert(false);
-    }
-#if __cplusplus >= 201103L
-    {
-    int a1[] = {1, 2, 3};
-    std::list<int, min_allocator<int>> l1(a1, a1+3);
-    std::list<int, min_allocator<int>>::iterator i = l1.erase(next(l1.cbegin()), l1.cbegin());
-    assert(false);
-    }
-#endif
-}
-
-#else
-
-int main()
-{
 }
-
-#endif
diff --git a/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_iter_iter_db1.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_iter_iter_db1.pass.cpp
new file mode 100644
index 000000000000..7fadb14affdd
--- /dev/null
+++ b/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_iter_iter_db1.pass.cpp
@@ -0,0 +1,36 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <list>
+
+// template <InputIterator Iter>
+//   iterator insert(const_iterator position, Iter first, Iter last);
+
+
+#define _LIBCPP_DEBUG 1
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+
+#include <list>
+#include <cstdlib>
+#include <cassert>
+#include "test_iterators.h"
+
+int main()
+{
+    {
+        std::list<int> v(100);
+        std::list<int> v2(100);
+        int a[] = {1, 2, 3, 4, 5};
+        const int N = sizeof(a)/sizeof(a[0]);
+        std::list<int>::iterator i = v.insert(next(v2.cbegin(), 10),
+                                        input_iterator<const int*>(a),
+                                       input_iterator<const int*>(a+N));
+        assert(false);
+    }
+}
diff --git a/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_rvalue_db1.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_rvalue_db1.pass.cpp
new file mode 100644
index 000000000000..0d0fd100fc91
--- /dev/null
+++ b/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_rvalue_db1.pass.cpp
@@ -0,0 +1,27 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <list>
+
+// iterator insert(const_iterator position, value_type&& x);
+
+#define _LIBCPP_DEBUG 1
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+
+#include <list>
+#include <cstdlib>
+#include <cassert>
+
+int main()
+{
+    std::list<int> v1(3);
+    std::list<int> v2(3);
+    v1.insert(v2.begin(), 4);
+    assert(false);
+}
\ No newline at end of file
diff --git a/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_size_value_db1.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_size_value_db1.pass.cpp
new file mode 100644
index 000000000000..4fdfbfa50cbb
--- /dev/null
+++ b/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_size_value_db1.pass.cpp
@@ -0,0 +1,27 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <list>
+
+// iterator insert(const_iterator position, size_type n, const value_type& x);
+
+#define _LIBCPP_DEBUG 1
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+
+#include <list>
+#include <cstdlib>
+#include <cassert>
+
+int main()
+{
+    std::list<int> c1(100);
+    std::list<int> c2;
+    std::list<int>::iterator i = c1.insert(next(c2.cbegin(), 10), 5, 1);
+    assert(false);
+}
diff --git a/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_value_db1.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_value_db1.pass.cpp
new file mode 100644
index 000000000000..9a13520b98eb
--- /dev/null
+++ b/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_value_db1.pass.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <list>
+
+// iterator insert(const_iterator position, const value_type& x);
+
+#define _LIBCPP_DEBUG 1
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+
+#include <list>
+#include <cstdlib>
+#include <cassert>
+
+
+int main()
+{
+    std::list<int> v1(3);
+    std::list<int> v2(3);
+    int i = 4;
+    v1.insert(v2.begin(), i);
+    assert(false);
+}
diff --git a/test/libcxx/containers/sequences/list/list.modifiers/pop_back_db1.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/pop_back_db1.pass.cpp
new file mode 100644
index 000000000000..795e66d9702a
--- /dev/null
+++ b/test/libcxx/containers/sequences/list/list.modifiers/pop_back_db1.pass.cpp
@@ -0,0 +1,33 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <list>
+
+// void pop_back();
+
+#define _LIBCPP_DEBUG 1
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+
+#include <list>
+#include <cstdlib>
+#include <cassert>
+
+int main()
+{
+    int a[] = {1, 2, 3};
+    std::list<int> c(a, a+3);
+    c.pop_back();
+    assert(c == std::list<int>(a, a+2));
+    c.pop_back();
+    assert(c == std::list<int>(a, a+1));
+    c.pop_back();
+    assert(c.empty());
+    c.pop_back(); // operation under test
+    assert(false);
+}
diff --git a/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list.pass.cpp b/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list.pass.cpp
new file mode 100644
index 000000000000..7a1180a9b585
--- /dev/null
+++ b/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list.pass.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <list>
+
+// void splice(const_iterator position, list& x);
+
+#define _LIBCPP_DEBUG 1
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+
+#include <list>
+#include <cstdlib>
+#include <cassert>
+
+int main()
+{
+    {
+        std::list<int> v1(3);
+        std::list<int> v2(3);
+        v1.splice(v2.begin(), v2);
+        assert(false);
+    }
+}
diff --git a/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_iter.pass.cpp b/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_iter.pass.cpp
new file mode 100644
index 000000000000..fa5243e322bf
--- /dev/null
+++ b/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_iter.pass.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <list>
+
+// void splice(const_iterator position, list<T,Allocator>& x, iterator i);
+
+#define _LIBCPP_DEBUG 1
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+
+#include <list>
+#include <cstdlib>
+#include <cassert>
+
+int main()
+{
+    {
+        std::list<int> v1(3);
+        std::list<int> v2(3);
+        v1.splice(v1.begin(), v2, v1.begin());
+        assert(false);
+    }
+}
diff --git a/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_iter_iter.pass.cpp b/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_iter_iter.pass.cpp
new file mode 100644
index 000000000000..a385b4cf7afa
--- /dev/null
+++ b/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_iter_iter.pass.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <list>
+
+// void splice(const_iterator position, list& x, iterator first, iterator last);
+
+#define _LIBCPP_DEBUG 1
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+
+#include <list>
+#include <cstdlib>
+#include <cassert>
+
+int main()
+{
+    {
+        std::list<int> v1(3);
+        std::list<int> v2(3);
+        v1.splice(v1.begin(), v2, v2.begin(), v1.end());
+        assert(false);
+    }
+}
diff --git a/test/libcxx/containers/sequences/list/list.special/db_swap_1.pass.cpp b/test/libcxx/containers/sequences/list/list.special/db_swap_1.pass.cpp
new file mode 100644
index 000000000000..900f338c29eb
--- /dev/null
+++ b/test/libcxx/containers/sequences/list/list.special/db_swap_1.pass.cpp
@@ -0,0 +1,36 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <list>
+
+// template <class T, class Alloc>
+//   void swap(list<T,Alloc>& x, list<T,Alloc>& y);
+
+#define _LIBCPP_DEBUG 1
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+
+#include <list>
+#include <cstdlib>
+#include <cassert>
+
+int main()
+{
+    int a1[] = {1, 3, 7, 9, 10};
+    int a2[] = {0, 2, 4, 5, 6, 8, 11};
+    std::list<int> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
+    std::list<int> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
+    std::list<int>::iterator i1 = c1.begin();
+    std::list<int>::iterator i2 = c2.begin();
+    swap(c1, c2);
+    c1.erase(i2);
+    c2.erase(i1);
+    std::list<int>::iterator j = i1;
+    c1.erase(i1); // called with iterator not refering to list.
+    assert(false);
+}
diff --git a/test/libcxx/containers/sequences/list/list.special/db_swap_2.pass.cpp b/test/libcxx/containers/sequences/list/list.special/db_swap_2.pass.cpp
new file mode 100644
index 000000000000..ace9a713aae7
--- /dev/null
+++ b/test/libcxx/containers/sequences/list/list.special/db_swap_2.pass.cpp
@@ -0,0 +1,36 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <list>
+
+// template <class T, class Alloc>
+//   void swap(list<T,Alloc>& x, list<T,Alloc>& y);
+
+
+#define _LIBCPP_DEBUG 1
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+
+#include <list>
+#include <cassert>
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+int main()
+{
+    // allocators do not compare equal
+    {
+        int a1[] = {1, 3, 7, 9, 10};
+        int a2[] = {0, 2, 4, 5, 6, 8, 11};
+        typedef test_allocator<int> A;
+        std::list<int, A> c1(a1, a1+sizeof(a1)/sizeof(a1[0]), A(1));
+        std::list<int, A> c2(a2, a2+sizeof(a2)/sizeof(a2[0]), A(2));
+        swap(c1, c2);
+        assert(false);
+    }
+}
diff --git a/test/std/containers/sequences/list/version.pass.cpp b/test/libcxx/containers/sequences/list/version.pass.cpp
index 097c013f52cb..097c013f52cb 100644
--- a/test/std/containers/sequences/list/version.pass.cpp
+++ b/test/libcxx/containers/sequences/list/version.pass.cpp
diff --git a/test/std/containers/sequences/vector/const_value_type.pass.cpp b/test/libcxx/containers/sequences/vector/const_value_type.pass.cpp
index e16e439dec4d..2a150f7cce54 100644
--- a/test/std/containers/sequences/vector/const_value_type.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/const_value_type.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <vector>
 
 // vector<const int> v;  // an extension
@@ -16,7 +18,5 @@
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     std::vector<const int> v = {1, 2, 3};
-#endif
 }
diff --git a/test/std/containers/sequences/vector/db_back.pass.cpp b/test/libcxx/containers/sequences/vector/db_back.pass.cpp
index 05f3d07712eb..05f3d07712eb 100644
--- a/test/std/containers/sequences/vector/db_back.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_back.pass.cpp
diff --git a/test/std/containers/sequences/vector/db_cback.pass.cpp b/test/libcxx/containers/sequences/vector/db_cback.pass.cpp
index 5eb1a353e8b0..5eb1a353e8b0 100644
--- a/test/std/containers/sequences/vector/db_cback.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_cback.pass.cpp
diff --git a/test/std/containers/sequences/vector/db_cfront.pass.cpp b/test/libcxx/containers/sequences/vector/db_cfront.pass.cpp
index 5e54da1d444e..5e54da1d444e 100644
--- a/test/std/containers/sequences/vector/db_cfront.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_cfront.pass.cpp
diff --git a/test/std/containers/sequences/vector/db_cindex.pass.cpp b/test/libcxx/containers/sequences/vector/db_cindex.pass.cpp
index 133aa5652824..133aa5652824 100644
--- a/test/std/containers/sequences/vector/db_cindex.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_cindex.pass.cpp
diff --git a/test/std/containers/sequences/vector/db_front.pass.cpp b/test/libcxx/containers/sequences/vector/db_front.pass.cpp
index 388058fb3159..388058fb3159 100644
--- a/test/std/containers/sequences/vector/db_front.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_front.pass.cpp
diff --git a/test/std/containers/sequences/vector/db_index.pass.cpp b/test/libcxx/containers/sequences/vector/db_index.pass.cpp
index 1daf076da67c..1daf076da67c 100644
--- a/test/std/containers/sequences/vector/db_index.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_index.pass.cpp
diff --git a/test/std/containers/sequences/vector/db_iterators_2.pass.cpp b/test/libcxx/containers/sequences/vector/db_iterators_2.pass.cpp
index 2d43843067b7..2d43843067b7 100644
--- a/test/std/containers/sequences/vector/db_iterators_2.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_iterators_2.pass.cpp
diff --git a/test/std/containers/sequences/vector/db_iterators_3.pass.cpp b/test/libcxx/containers/sequences/vector/db_iterators_3.pass.cpp
index 051d66c33394..051d66c33394 100644
--- a/test/std/containers/sequences/vector/db_iterators_3.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_iterators_3.pass.cpp
diff --git a/test/std/containers/sequences/vector/db_iterators_4.pass.cpp b/test/libcxx/containers/sequences/vector/db_iterators_4.pass.cpp
index 4c2aa628de14..4c2aa628de14 100644
--- a/test/std/containers/sequences/vector/db_iterators_4.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_iterators_4.pass.cpp
diff --git a/test/std/containers/sequences/vector/db_iterators_5.pass.cpp b/test/libcxx/containers/sequences/vector/db_iterators_5.pass.cpp
index 1b1090499c27..1b1090499c27 100644
--- a/test/std/containers/sequences/vector/db_iterators_5.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_iterators_5.pass.cpp
diff --git a/test/std/containers/sequences/vector/db_iterators_6.pass.cpp b/test/libcxx/containers/sequences/vector/db_iterators_6.pass.cpp
index 424bc939b136..424bc939b136 100644
--- a/test/std/containers/sequences/vector/db_iterators_6.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_iterators_6.pass.cpp
diff --git a/test/std/containers/sequences/vector/db_iterators_7.pass.cpp b/test/libcxx/containers/sequences/vector/db_iterators_7.pass.cpp
index 72cdb10cbc85..72cdb10cbc85 100644
--- a/test/std/containers/sequences/vector/db_iterators_7.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_iterators_7.pass.cpp
diff --git a/test/std/containers/sequences/vector/db_iterators_8.pass.cpp b/test/libcxx/containers/sequences/vector/db_iterators_8.pass.cpp
index 7b898533197c..7b898533197c 100644
--- a/test/std/containers/sequences/vector/db_iterators_8.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_iterators_8.pass.cpp
diff --git a/test/std/containers/sequences/vector/version.pass.cpp b/test/libcxx/containers/sequences/vector/version.pass.cpp
index 2c4fa1263de3..2c4fa1263de3 100644
--- a/test/std/containers/sequences/vector/version.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/version.pass.cpp
diff --git a/test/libcxx/containers/unord/key_value_traits.pass.cpp b/test/libcxx/containers/unord/key_value_traits.pass.cpp
new file mode 100644
index 000000000000..a6d1ea7a527c
--- /dev/null
+++ b/test/libcxx/containers/unord/key_value_traits.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.
+//
+//===----------------------------------------------------------------------===//
+
+#include <__hash_table>
+#include <unordered_map>
+#include <unordered_set>
+#include <type_traits>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+void testKeyValueTrait() {
+  {
+    typedef int Tp;
+    typedef std::__hash_key_value_types<Tp> Traits;
+    static_assert((std::is_same<Traits::key_type, int>::value), "");
+    static_assert((std::is_same<Traits::__node_value_type, Tp>::value), "");
+    static_assert((std::is_same<Traits::__container_value_type, Tp>::value), "");
+    static_assert(Traits::__is_map == false, "");
+  }
+  {
+    typedef std::pair<int, int> Tp;
+    typedef std::__hash_key_value_types<Tp> Traits;
+    static_assert((std::is_same<Traits::key_type, Tp>::value), "");
+    static_assert((std::is_same<Traits::__node_value_type, Tp>::value), "");
+    static_assert((std::is_same<Traits::__container_value_type, Tp>::value), "");
+    static_assert(Traits::__is_map == false, "");
+  }
+  {
+    typedef std::pair<const int, int> Tp;
+    typedef std::__hash_key_value_types<Tp> Traits;
+    static_assert((std::is_same<Traits::key_type, Tp>::value), "");
+    static_assert((std::is_same<Traits::__node_value_type, Tp>::value), "");
+    static_assert((std::is_same<Traits::__container_value_type, Tp>::value), "");
+    static_assert(Traits::__is_map == false, "");
+  }
+  {
+    typedef std::__hash_value_type<int, int> Tp;
+    typedef std::__hash_key_value_types<Tp> Traits;
+    static_assert((std::is_same<Traits::key_type, int>::value), "");
+    static_assert((std::is_same<Traits::mapped_type, int>::value), "");
+    static_assert((std::is_same<Traits::__node_value_type, Tp>::value), "");
+    static_assert((std::is_same<Traits::__container_value_type,
+                               std::pair<const int, int> >::value), "");
+    static_assert((std::is_same<Traits::__map_value_type,
+                               std::pair<const int, int> >::value), "");
+    static_assert(Traits::__is_map == true, "");
+  }
+}
+
+int main() {
+  testKeyValueTrait();
+}
diff --git a/test/std/containers/unord/next_prime.pass.cpp b/test/libcxx/containers/unord/next_prime.pass.cpp
index 266d7f1f9d1e..266d7f1f9d1e 100644
--- a/test/std/containers/unord/next_prime.pass.cpp
+++ b/test/libcxx/containers/unord/next_prime.pass.cpp
diff --git a/test/std/containers/unord/unord.map/db_iterators_7.pass.cpp b/test/libcxx/containers/unord/unord.map/db_iterators_7.pass.cpp
index b8db0a35ffc3..b8db0a35ffc3 100644
--- a/test/std/containers/unord/unord.map/db_iterators_7.pass.cpp
+++ b/test/libcxx/containers/unord/unord.map/db_iterators_7.pass.cpp
diff --git a/test/std/containers/unord/unord.map/db_iterators_8.pass.cpp b/test/libcxx/containers/unord/unord.map/db_iterators_8.pass.cpp
index c923dd77862e..c923dd77862e 100644
--- a/test/std/containers/unord/unord.map/db_iterators_8.pass.cpp
+++ b/test/libcxx/containers/unord/unord.map/db_iterators_8.pass.cpp
diff --git a/test/std/containers/unord/unord.map/db_local_iterators_7.pass.cpp b/test/libcxx/containers/unord/unord.map/db_local_iterators_7.pass.cpp
index fa1886bfff18..fa1886bfff18 100644
--- a/test/std/containers/unord/unord.map/db_local_iterators_7.pass.cpp
+++ b/test/libcxx/containers/unord/unord.map/db_local_iterators_7.pass.cpp
diff --git a/test/std/containers/unord/unord.map/db_local_iterators_8.pass.cpp b/test/libcxx/containers/unord/unord.map/db_local_iterators_8.pass.cpp
index 4b071cad7b47..4b071cad7b47 100644
--- a/test/std/containers/unord/unord.map/db_local_iterators_8.pass.cpp
+++ b/test/libcxx/containers/unord/unord.map/db_local_iterators_8.pass.cpp
diff --git a/test/std/containers/unord/unord.map/version.pass.cpp b/test/libcxx/containers/unord/unord.map/version.pass.cpp
index fc47a326c571..fc47a326c571 100644
--- a/test/std/containers/unord/unord.map/version.pass.cpp
+++ b/test/libcxx/containers/unord/unord.map/version.pass.cpp
diff --git a/test/libcxx/containers/unord/unord.set/insert_dup_alloc.pass.cpp b/test/libcxx/containers/unord/unord.set/insert_dup_alloc.pass.cpp
deleted file mode 100644
index 76ceafed2208..000000000000
--- a/test/libcxx/containers/unord/unord.set/insert_dup_alloc.pass.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// Check that we don't allocate when trying to insert a duplicate value into a
-// unordered_set. See PR12999 http://llvm.org/bugs/show_bug.cgi?id=12999
-
-#include <cassert>
-#include <unordered_set>
-#include "count_new.hpp"
-#include "MoveOnly.h"
-
-int main()
-{
-    {
-    std::unordered_set<int> s;
-    assert(globalMemCounter.checkNewCalledEq(0));
-
-    for(int i=0; i < 100; ++i)
-        s.insert(3);
-
-    assert(s.size() == 1);
-    assert(s.count(3) == 1);
-    assert(globalMemCounter.checkNewCalledEq(2));
-    }
-    assert(globalMemCounter.checkOutstandingNewEq(0));
-    globalMemCounter.reset();
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    {
-    std::unordered_set<MoveOnly> s;
-    assert(globalMemCounter.checkNewCalledEq(0));
-
-    for(int i=0; i<100; i++)
-        s.insert(MoveOnly(3));
-
-    assert(s.size() == 1);
-    assert(s.count(MoveOnly(3)) == 1);
-    assert(globalMemCounter.checkNewCalledEq(2));
-    }
-    assert(globalMemCounter.checkOutstandingNewEq(0));
-    globalMemCounter.reset();
-#endif
-}
diff --git a/test/std/containers/unord/unord.set/version.pass.cpp b/test/libcxx/containers/unord/unord.set/version.pass.cpp
index d651ebdfc456..d651ebdfc456 100644
--- a/test/std/containers/unord/unord.set/version.pass.cpp
+++ b/test/libcxx/containers/unord/unord.set/version.pass.cpp
diff --git a/test/std/depr/depr.c.headers/extern_c.pass.cpp b/test/libcxx/depr/depr.c.headers/extern_c.pass.cpp
index d4d8b5fafdde..d4d8b5fafdde 100644
--- a/test/std/depr/depr.c.headers/extern_c.pass.cpp
+++ b/test/libcxx/depr/depr.c.headers/extern_c.pass.cpp
diff --git a/test/std/depr/depr.str.strstreams/version.pass.cpp b/test/libcxx/depr/depr.str.strstreams/version.pass.cpp
index f27665f15bcd..f27665f15bcd 100644
--- a/test/std/depr/depr.str.strstreams/version.pass.cpp
+++ b/test/libcxx/depr/depr.str.strstreams/version.pass.cpp
diff --git a/test/libcxx/diagnostics/assertions/version_cassert.pass.cpp b/test/libcxx/diagnostics/assertions/version_cassert.pass.cpp
new file mode 100644
index 000000000000..f123a05256ec
--- /dev/null
+++ b/test/libcxx/diagnostics/assertions/version_cassert.pass.cpp
@@ -0,0 +1,20 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test <cassert>
+
+#include <cassert>
+
+#ifndef _LIBCPP_VERSION
+#error _LIBCPP_VERSION not defined
+#endif
+
+int main()
+{
+}
diff --git a/test/libcxx/diagnostics/errno/version_cerrno.pass.cpp b/test/libcxx/diagnostics/errno/version_cerrno.pass.cpp
new file mode 100644
index 000000000000..7cd2be8efa92
--- /dev/null
+++ b/test/libcxx/diagnostics/errno/version_cerrno.pass.cpp
@@ -0,0 +1,19 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test <cerrno>
+
+#include <cerrno>
+
+#ifndef _LIBCPP_VERSION
+#error _LIBCPP_VERSION not defined
+#endif
+
+int main() {}
diff --git a/test/std/diagnostics/std.exceptions/version.pass.cpp b/test/libcxx/diagnostics/std.exceptions/version.pass.cpp
index d9ab009a4365..d9ab009a4365 100644
--- a/test/std/diagnostics/std.exceptions/version.pass.cpp
+++ b/test/libcxx/diagnostics/std.exceptions/version.pass.cpp
diff --git a/test/std/diagnostics/syserr/version.pass.cpp b/test/libcxx/diagnostics/syserr/version.pass.cpp
index 3851150fdf90..3851150fdf90 100644
--- a/test/std/diagnostics/syserr/version.pass.cpp
+++ b/test/libcxx/diagnostics/syserr/version.pass.cpp
diff --git a/test/libcxx/experimental/containers/sequences/dynarray/dynarray.cons/alloc.pass.cpp b/test/libcxx/experimental/containers/sequences/dynarray/dynarray.cons/alloc.pass.cpp
index d274bc030881..c6a83cc61bdc 100644
--- a/test/libcxx/experimental/containers/sequences/dynarray/dynarray.cons/alloc.pass.cpp
+++ b/test/libcxx/experimental/containers/sequences/dynarray/dynarray.cons/alloc.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // dynarray.cons
 
 // template <class Alloc>
@@ -20,10 +21,8 @@
 
 // ~dynarray();
 
-  
-#include <__config>
 
-#if _LIBCPP_STD_VER > 11
+#include <__config>
 
 #include <experimental/dynarray>
 #include <cassert>
@@ -44,7 +43,7 @@ void check_allocator ( const dynarray<T> &dyn, const Allocator &alloc ) {
 template <class T, class Allocator>
 void test ( const std::initializer_list<T> &vals, const Allocator &alloc ) {
     typedef dynarray<T> dynA;
-    
+
     dynA d1 ( vals, alloc );
     assert ( d1.size () == vals.size() );
     assert ( std::equal ( vals.begin (), vals.end (), d1.begin (), d1.end ()));
@@ -55,7 +54,7 @@ void test ( const std::initializer_list<T> &vals, const Allocator &alloc ) {
 template <class T, class Allocator>
 void test ( const T &val, const Allocator &alloc1, const Allocator &alloc2 ) {
     typedef dynarray<T> dynA;
-    
+
     dynA d1 ( 4, alloc1 );
     assert ( d1.size () == 4 );
     assert ( std::all_of ( d1.begin (), d1.end (), []( const T &item ){ return item == T(); } ));
@@ -68,19 +67,17 @@ void test ( const T &val, const Allocator &alloc1, const Allocator &alloc2 ) {
 
     dynA d3 ( d2, alloc2 );
     assert ( d3.size () == 7 );
-    assert ( std::all_of ( d3.begin (), d3.end (), [&val]( const T &item ){ return item == val; } ));   
+    assert ( std::all_of ( d3.begin (), d3.end (), [&val]( const T &item ){ return item == val; } ));
     check_allocator ( d3, alloc2 );
     }
 
 int main()
 {
-//  This test is waiting on the resolution of LWG issue #2235 
+//  This test is waiting on the resolution of LWG issue #2235
 //     typedef test_allocator<char> Alloc;
 //     typedef std::basic_string<char, std::char_traits<char>, Alloc> nstr;
-// 
+//
 //     test ( nstr("fourteen"), Alloc(3), Alloc(4) );
 //     test ( { nstr("1"), nstr("1"), nstr("2"), nstr("3"), nstr("5"), nstr("8")}, Alloc(6));
 }
-#else
-int main() {}
-#endif
+
diff --git a/test/libcxx/experimental/containers/sequences/dynarray/dynarray.cons/default.pass.cpp b/test/libcxx/experimental/containers/sequences/dynarray/dynarray.cons/default.pass.cpp
index 738c0c72592e..cd5c56c7ac51 100644
--- a/test/libcxx/experimental/containers/sequences/dynarray/dynarray.cons/default.pass.cpp
+++ b/test/libcxx/experimental/containers/sequences/dynarray/dynarray.cons/default.pass.cpp
@@ -35,7 +35,7 @@ using std::experimental::dynarray;
 template <class T>
 void testInitList( const std::initializer_list<T> &vals ) {
     typedef dynarray<T> dynA;
-    
+
     dynA d1 ( vals );
     assert ( d1.size () == vals.size() );
     assert ( std::equal ( vals.begin (), vals.end (), d1.begin (), d1.end ()));
@@ -45,7 +45,7 @@ void testInitList( const std::initializer_list<T> &vals ) {
 template <class T>
 void test ( const T &val, bool DefaultValueIsIndeterminate = false) {
     typedef dynarray<T> dynA;
-    
+
     dynA d1 ( 4 );
     assert ( d1.size () == 4 );
     if (!DefaultValueIsIndeterminate) {
@@ -58,7 +58,7 @@ void test ( const T &val, bool DefaultValueIsIndeterminate = false) {
 
     dynA d3 ( d2 );
     assert ( d3.size () == 7 );
-    assert ( std::all_of ( d3.begin (), d3.end (), [&val]( const T &item ){ return item == val; } ));   
+    assert ( std::all_of ( d3.begin (), d3.end (), [&val]( const T &item ){ return item == val; } ));
     }
 
 void test_bad_length () {
@@ -76,12 +76,12 @@ int main()
     test<double> ( 14.0, true );
     test<std::complex<double>> ( std::complex<double> ( 14, 0 ));
     test<std::string> ( "fourteen" );
-    
+
     testInitList( { 1, 1, 2, 3, 5, 8 } );
     testInitList( { 1., 1., 2., 3., 5., 8. } );
     testInitList( { std::string("1"), std::string("1"), std::string("2"), std::string("3"),
                   std::string("5"), std::string("8")} );
-    
+
 //  Make sure we don't pick up the Allocator version here
     dynarray<long> d1 ( 20, 3 );
     assert ( d1.size() == 20 );
diff --git a/test/libcxx/experimental/containers/sequences/dynarray/dynarray.data/default.pass.cpp b/test/libcxx/experimental/containers/sequences/dynarray/dynarray.data/default.pass.cpp
index 1bbd8cde92fe..84c602925cb4 100644
--- a/test/libcxx/experimental/containers/sequences/dynarray/dynarray.data/default.pass.cpp
+++ b/test/libcxx/experimental/containers/sequences/dynarray/dynarray.data/default.pass.cpp
@@ -42,7 +42,7 @@ void dyn_test( dynarray<T> &dyn, bool CheckEquals = true) {
     }
 }
 
-    
+
 
 template <class T>
 void test(const T &val, bool DefaultValueIsIndeterminate = false) {
@@ -53,7 +53,7 @@ void test(const T &val, bool DefaultValueIsIndeterminate = false) {
     dynA d1(4);
     dyn_test(d1, CheckDefaultValues);
     dyn_test_const(d1, CheckDefaultValues);
-    
+
     dynA d2 (7, val);
     dyn_test ( d2 );
     dyn_test_const ( d2 );
diff --git a/test/libcxx/experimental/containers/sequences/dynarray/dynarray.mutate/default.pass.cpp b/test/libcxx/experimental/containers/sequences/dynarray/dynarray.mutate/default.pass.cpp
index c57887ddaf94..376c94a6bcd8 100644
--- a/test/libcxx/experimental/containers/sequences/dynarray/dynarray.mutate/default.pass.cpp
+++ b/test/libcxx/experimental/containers/sequences/dynarray/dynarray.mutate/default.pass.cpp
@@ -7,15 +7,14 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // dynarray.data
 
 // void fill(const T& v);
 // const T* data() const noexcept;
 
-  
-#include <__config>
 
-#if _LIBCPP_STD_VER > 11
+#include <__config>
 
 #include <experimental/dynarray>
 #include <cassert>
@@ -29,11 +28,11 @@ using std::experimental::dynarray;
 template <class T>
 void test ( const T &val ) {
     typedef dynarray<T> dynA;
-    
+
     dynA d1 ( 4 );
     d1.fill ( val );
-    assert ( std::all_of ( d1.begin (), d1.end (), 
-                    [&val]( const T &item ){ return item == val; } ));  
+    assert ( std::all_of ( d1.begin (), d1.end (),
+                    [&val]( const T &item ){ return item == val; } ));
     }
 
 int main()
@@ -43,6 +42,4 @@ int main()
     test<std::complex<double>> ( std::complex<double> ( 14, 0 ));
     test<std::string> ( "fourteen" );
 }
-#else
-int main() {}
-#endif
+
diff --git a/test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/at.pass.cpp b/test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/at.pass.cpp
index 8c0d08538716..a6825b68d0f1 100644
--- a/test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/at.pass.cpp
+++ b/test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/at.pass.cpp
@@ -7,15 +7,14 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // XFAIL: libcpp-no-exceptions
 // dynarray.overview
 
 // const_reference at(size_type n) const;
 //       reference at(size_type n);
-  
-#include <__config>
 
-#if _LIBCPP_STD_VER > 11
+#include <__config>
 
 #include <experimental/dynarray>
 #include <cassert>
@@ -73,7 +72,7 @@ void dyn_test ( dynarray<T> &dyn, const std::initializer_list<T> &vals ) {
 template <class T>
 void test ( std::initializer_list<T> vals ) {
     typedef dynarray<T> dynA;
-    
+
     dynA d1 ( vals );
     dyn_test ( d1, vals );
     dyn_test_const ( d1, vals );
@@ -83,13 +82,11 @@ int main()
 {
     test ( { 1, 1, 2, 3, 5, 8 } );
     test ( { 1., 1., 2., 3., 5., 8. } );
-    test ( { std::string("1"), std::string("1"), std::string("2"), std::string("3"), 
+    test ( { std::string("1"), std::string("1"), std::string("2"), std::string("3"),
                 std::string("5"), std::string("8")} );
 
     test<int> ( {} );
     test<std::complex<double>> ( {} );
     test<std::string> ( {} );
 }
-#else
-int main() {}
-#endif
+
diff --git a/test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/begin_end.pass.cpp b/test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/begin_end.pass.cpp
index 695e1aa9f14a..fe425b7e8c18 100644
--- a/test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/begin_end.pass.cpp
+++ b/test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/begin_end.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // dynarray.overview
 
 
@@ -16,7 +17,7 @@
 // iterator       end()          noexcept;
 // const_iterator end()    const noexcept;
 // const_iterator cend()   const noexcept;
-// 
+//
 // reverse_iterator       rbegin()        noexcept;
 // const_reverse_iterator rbegin()  const noexcept;
 // const_reverse_iterator crbegin() const noexcept;
@@ -24,10 +25,8 @@
 // const_reverse_iterator rend()    const noexcept;
 // const_reverse_iterator crend()   const noexcept;
 
-  
-#include <__config>
 
-#if _LIBCPP_STD_VER > 11
+#include <__config>
 
 #include <experimental/dynarray>
 #include <cassert>
@@ -86,11 +85,11 @@ void dyn_test ( dynarray<T> &dyn ) {
 template <class T>
 void test ( const T &val ) {
     typedef dynarray<T> dynA;
-    
+
     dynA d1 ( 4 );
     dyn_test ( d1 );
     dyn_test_const ( d1 );
-    
+
     dynA d2 ( 7, val );
     dyn_test ( d2 );
     dyn_test_const ( d2 );
@@ -103,6 +102,4 @@ int main()
     test<std::complex<double>> ( std::complex<double> ( 14, 0 ));
     test<std::string> ( "fourteen" );
 }
-#else
-int main() {}
-#endif
+
diff --git a/test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/capacity.pass.cpp b/test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/capacity.pass.cpp
index 6d28eef1b057..95262aab1bdc 100644
--- a/test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/capacity.pass.cpp
+++ b/test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/capacity.pass.cpp
@@ -7,16 +7,15 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // dynarray.overview
 
 // size_type size()     const noexcept;
 // size_type max_size() const noexcept;
-// bool      empty()    const noexcept;  
+// bool      empty()    const noexcept;
 
 #include <__config>
 
-#if _LIBCPP_STD_VER > 11
-
 #include <experimental/dynarray>
 #include <cassert>
 
@@ -36,7 +35,7 @@ void dyn_test ( const dynarray<T> &dyn, size_t sz ) {
 template <class T>
 void test ( std::initializer_list<T> vals ) {
     typedef dynarray<T> dynA;
-    
+
     dynA d1 ( vals );
     dyn_test ( d1, vals.size ());
     }
@@ -45,13 +44,11 @@ int main()
 {
     test ( { 1, 1, 2, 3, 5, 8 } );
     test ( { 1., 1., 2., 3., 5., 8. } );
-    test ( { std::string("1"), std::string("1"), std::string("2"), std::string("3"), 
+    test ( { std::string("1"), std::string("1"), std::string("2"), std::string("3"),
                 std::string("5"), std::string("8")} );
 
     test<int> ( {} );
     test<std::complex<double>> ( {} );
     test<std::string> ( {} );
 }
-#else
-int main() {}
-#endif
+
diff --git a/test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/front_back.pass.cpp b/test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/front_back.pass.cpp
index 2af862a5530f..4f1d0978dd11 100644
--- a/test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/front_back.pass.cpp
+++ b/test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/front_back.pass.cpp
@@ -58,7 +58,7 @@ void test ( const T &val, bool DefaultValueIsIndeterminate = false) {
     dynA d1 ( 4 );
     dyn_test ( d1, CheckDefaultValues );
     dyn_test_const ( d1, CheckDefaultValues );
-    
+
     dynA d2 ( 7, val );
     dyn_test ( d2 );
     dyn_test_const ( d2 );
diff --git a/test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/indexing.pass.cpp b/test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/indexing.pass.cpp
index 7317a2023cb1..4bcb229ebce0 100644
--- a/test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/indexing.pass.cpp
+++ b/test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/indexing.pass.cpp
@@ -7,14 +7,13 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // dynarray.overview
 
 // const_reference at(size_type n) const;
 //       reference at(size_type n);
-  
-#include <__config>
 
-#if _LIBCPP_STD_VER > 11
+#include <__config>
 
 #include <experimental/dynarray>
 #include <cassert>
@@ -49,7 +48,7 @@ void dyn_test ( dynarray<T> &dyn, const std::initializer_list<T> &vals ) {
 template <class T>
 void test ( std::initializer_list<T> vals ) {
     typedef dynarray<T> dynA;
-    
+
     dynA d1 ( vals );
     dyn_test ( d1, vals );
     dyn_test_const ( d1, vals );
@@ -59,13 +58,11 @@ int main()
 {
     test ( { 1, 1, 2, 3, 5, 8 } );
     test ( { 1., 1., 2., 3., 5., 8. } );
-    test ( { std::string("1"), std::string("1"), std::string("2"), std::string("3"), 
+    test ( { std::string("1"), std::string("1"), std::string("2"), std::string("3"),
                 std::string("5"), std::string("8")} );
 
     test<int> ( {} );
     test<std::complex<double>> ( {} );
     test<std::string> ( {} );
 }
-#else
-int main() {}
-#endif
+
diff --git a/test/libcxx/experimental/containers/sequences/dynarray/dynarray.traits/default.pass.cpp b/test/libcxx/experimental/containers/sequences/dynarray/dynarray.traits/default.pass.cpp
index 9b8240d4cd82..48da6d885773 100644
--- a/test/libcxx/experimental/containers/sequences/dynarray/dynarray.traits/default.pass.cpp
+++ b/test/libcxx/experimental/containers/sequences/dynarray/dynarray.traits/default.pass.cpp
@@ -7,15 +7,14 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // dynarray.data
 
 // template <class Type, class Alloc>
 //   struct uses_allocator<dynarray<Type>, Alloc> : true_type { };
 
-  
-#include <__config>
 
-#if _LIBCPP_STD_VER > 11
+#include <__config>
 
 #include <experimental/dynarray>
 #include "test_allocator.h"
@@ -26,6 +25,4 @@ int main()
 {
     static_assert ( std::uses_allocator<dynarray<int>, test_allocator<int>>::value, "" );
 }
-#else
-int main() {}
-#endif
+
diff --git a/test/libcxx/experimental/containers/sequences/dynarray/dynarray.zero/default.pass.cpp b/test/libcxx/experimental/containers/sequences/dynarray/dynarray.zero/default.pass.cpp
index 93f3b18f192f..c0e0180930e9 100644
--- a/test/libcxx/experimental/containers/sequences/dynarray/dynarray.zero/default.pass.cpp
+++ b/test/libcxx/experimental/containers/sequences/dynarray/dynarray.zero/default.pass.cpp
@@ -7,18 +7,17 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // dynarray.zero
 
 // dynarray shall provide support for the special case of construction with a size of zero.
-// In the case that the size is zero, begin() == end() == unique value. 
-// The return value of data() is unspecified. 
+// In the case that the size is zero, begin() == end() == unique value.
+// The return value of data() is unspecified.
 // The effect of calling front() or back() for a zero-sized dynarray is undefined.
 
 
-  
-#include <__config>
 
-#if _LIBCPP_STD_VER > 11
+#include <__config>
 
 #include <experimental/dynarray>
 #include <cassert>
@@ -32,7 +31,7 @@ using std::experimental::dynarray;
 template <class T>
 void test ( ) {
     typedef dynarray<T> dynA;
-    
+
     dynA d1 ( 0 );
     assert ( d1.size() == 0 );
     assert ( d1.begin() == d1.end ());
@@ -45,6 +44,4 @@ int main()
     test<std::complex<double>> ();
     test<std::string> ();
 }
-#else
-int main() {}
-#endif
+
diff --git a/test/libcxx/experimental/filesystem/class.path/path.req/is_pathable.pass.cpp b/test/libcxx/experimental/filesystem/class.path/path.req/is_pathable.pass.cpp
new file mode 100644
index 000000000000..94de2108f8b5
--- /dev/null
+++ b/test/libcxx/experimental/filesystem/class.path/path.req/is_pathable.pass.cpp
@@ -0,0 +1,101 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// template <class Tp> struct __is_pathable
+
+// [path.req]
+// In addition to the requirements (5), function template parameters named
+// `Source` shall be one of:
+// * basic_string<_ECharT, _Traits, _Alloc>
+// * InputIterator with a value_type of _ECharT
+// * A character array, which points to a NTCTS after array-to-pointer decay.
+
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "min_allocator.h"
+
+namespace fs = std::experimental::filesystem;
+
+using fs::__is_pathable;
+
+template <class Tp>
+struct Identity { typedef Tp type; };
+
+template <class Source>
+Identity<Source> CheckSourceType(Source const&);
+
+template <class Tp>
+using GetSourceType = typename decltype(CheckSourceType(std::declval<Tp>()))::type;
+
+template <class Tp, class Exp,
+          class ExpQual = typename std::remove_const<Exp>::type>
+using CheckPass = std::is_same<ExpQual, GetSourceType<Tp>>;
+
+template <class Source>
+using CheckPassSource = std::integral_constant<bool,
+        CheckPass<Source&,        Source>::value &&
+        CheckPass<Source const&,  Source>::value &&
+        CheckPass<Source&&,       Source>::value &&
+        CheckPass<Source const&&, Source>::value
+  >;
+
+template <class CharT>
+struct MakeTestType {
+  using value_type = CharT;
+  using string_type = std::basic_string<CharT>;
+  using string_type2 = std::basic_string<CharT, std::char_traits<CharT>, min_allocator<CharT>>;
+  using cstr_type = CharT* const;
+  using const_cstr_type = const CharT*;
+  using array_type = CharT[25];
+  using const_array_type = const CharT[25];
+  using iter_type = input_iterator<CharT*>;
+  using bad_iter_type = input_iterator<signed char*>;
+
+  template <class TestT>
+  static void AssertPathable() {
+    static_assert(__is_pathable<TestT>::value, "");
+    static_assert(CheckPassSource<TestT>::value, "cannot pass as Source const&");
+    ASSERT_SAME_TYPE(CharT, typename __is_pathable<TestT>::__char_type);
+  }
+
+  template <class TestT>
+  static void AssertNotPathable() {
+    static_assert(!__is_pathable<TestT>::value, "");
+  }
+
+  static void Test() {
+    AssertPathable<string_type>();
+    AssertPathable<string_type2>();
+    AssertPathable<cstr_type>();
+    AssertPathable<const_cstr_type>();
+    AssertPathable<array_type>();
+    AssertPathable<const_array_type>();
+    AssertPathable<iter_type>();
+
+    AssertNotPathable<CharT>();
+    AssertNotPathable<bad_iter_type>();
+    AssertNotPathable<signed char*>();
+  }
+};
+
+int main() {
+  MakeTestType<char>::Test();
+  MakeTestType<wchar_t>::Test();
+  MakeTestType<char16_t>::Test();
+  MakeTestType<char32_t>::Test();
+}
diff --git a/test/libcxx/experimental/filesystem/lit.local.cfg b/test/libcxx/experimental/filesystem/lit.local.cfg
new file mode 100644
index 000000000000..3d9360431f48
--- /dev/null
+++ b/test/libcxx/experimental/filesystem/lit.local.cfg
@@ -0,0 +1,3 @@
+# Disable all of the filesystem tests if the correct feature is not available.
+if 'c++filesystem' not in config.available_features:
+  config.unsupported = True
diff --git a/test/libcxx/experimental/filesystem/version.pass.cpp b/test/libcxx/experimental/filesystem/version.pass.cpp
new file mode 100644
index 000000000000..723380a26fba
--- /dev/null
+++ b/test/libcxx/experimental/filesystem/version.pass.cpp
@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+#include <experimental/filesystem>
+
+#ifndef _LIBCPP_VERSION
+#error _LIBCPP_VERSION not defined
+#endif
+
+int main()
+{
+}
diff --git a/test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp b/test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp
new file mode 100644
index 000000000000..83b304196371
--- /dev/null
+++ b/test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp
@@ -0,0 +1,178 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// template <class U1, class U2, class ...Args1, class ...Args2>
+// void polymorphic_allocator<T>::construct(pair<T1, T2>*, piecewise_construct_t
+//                                          tuple<Args1...> x, tuple<Args2...>)
+
+// The stardard specifiers a tranformation to uses-allocator construction as
+// follows:
+//  - If uses_allocator_v<T1,memory_resource*> is false and
+//      is_constructible_v<T,Args1...> is true, then xprime is x.
+//  - Otherwise, if uses_allocator_v<T1,memory_resource*> is true and
+//      is_constructible_v<T1,allocator_arg_t,memory_resource*,Args1...> is true,
+//      then xprime is
+//      tuple_cat(make_tuple(allocator_arg, this->resource()), std::move(x)).
+//  - Otherwise, if uses_allocator_v<T1,memory_resource*> is true and
+//      is_constructible_v<T1,Args1...,memory_resource*> is true, then xprime is
+//      tuple_cat(std::move(x), make_tuple(this->resource())).
+//  - Otherwise the program is ill formed.
+//
+// The use of "xprime = tuple_cat(..., std::move(x), ...)" causes all of the
+// objects in 'x' to be copied into 'xprime'. If 'x' contains any types which
+// are stored by value this causes an unessary copy to occur. To prevent this
+//  libc++ changes this call into
+// "xprime = forward_as_tuple(..., std::get<Idx>(std::move(x))..., ...)".
+// 'xprime' contains references to the values in 'x' instead of copying them.
+
+// This test checks the number of copies incurred to the elements in
+// 'tuple<Args1...>' and 'tuple<Args2...>'.
+
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <utility>
+#include <tuple>
+#include <cassert>
+#include <cstdlib>
+#include "test_memory_resource.hpp"
+
+namespace ex = std::experimental::pmr;
+
+template <class T>
+struct TestHarness {
+    TestResource R;
+    ex::memory_resource * M = &R;
+    ex::polymorphic_allocator<T> A = M;
+    bool constructed = false;
+    T * ptr;
+
+    TestHarness() : ptr(A.allocate(1)) {}
+
+    template <class ...Args>
+    void construct(Args&&... args) {
+        A.construct(ptr, std::forward<Args>(args)...);
+        constructed = true;
+    }
+
+    ~TestHarness() {
+        if (constructed) A.destroy(ptr);
+        A.deallocate(ptr, 1);
+    }
+};
+
+struct CountCopies {
+  int count;
+  CountCopies() : count(0) {}
+  CountCopies(CountCopies const& o) : count(o.count + 1) {}
+};
+
+struct CountCopiesAllocV1 {
+  typedef ex::memory_resource* allocator_type;
+  allocator_type alloc;
+  int count;
+  CountCopiesAllocV1() : alloc(nullptr), count(0) {}
+  CountCopiesAllocV1(std::allocator_arg_t, allocator_type const& a,
+                     CountCopiesAllocV1 const& o) : alloc(a), count(o.count + 1)
+  {}
+
+  CountCopiesAllocV1(CountCopiesAllocV1 const& o) : count(o.count + 1) {}
+};
+
+
+struct CountCopiesAllocV2 {
+  typedef ex::memory_resource* allocator_type;
+  allocator_type alloc;
+  int count;
+  CountCopiesAllocV2() : alloc(nullptr), count(0) {}
+  CountCopiesAllocV2(CountCopiesAllocV2 const& o, allocator_type const& a)
+    : alloc(a), count(o.count + 1)
+  { }
+
+  CountCopiesAllocV2(CountCopiesAllocV2 const& o) : count(o.count + 1) {}
+};
+
+
+int main()
+{
+    using PMR = ex::memory_resource*;
+    using PMA = ex::polymorphic_allocator<char>;
+
+    {
+        using T = CountCopies;
+        using U = CountCopiesAllocV1;
+        using P = std::pair<T, U>;
+        using TH = TestHarness<P>;
+
+        std::tuple<T> t1;
+        std::tuple<U> t2;
+
+        TestHarness<P> h;
+        h.construct(std::piecewise_construct, t1, t2);
+        P const& p = *h.ptr;
+        assert(p.first.count == 2);
+        assert(p.second.count == 2);
+        assert(p.second.alloc == h.M);
+    }
+    {
+        using T = CountCopiesAllocV1;
+        using U = CountCopiesAllocV2;
+        using P = std::pair<T, U>;
+        using TH = TestHarness<P>;
+
+        std::tuple<T> t1;
+        std::tuple<U> t2;
+
+        TestHarness<P> h;
+        h.construct(std::piecewise_construct, std::move(t1), std::move(t2));
+        P const& p = *h.ptr;
+        assert(p.first.count == 2);
+        assert(p.first.alloc == h.M);
+        assert(p.second.count == 2);
+        assert(p.second.alloc == h.M);
+    }
+    {
+        using T = CountCopiesAllocV2;
+        using U = CountCopiesAllocV1;
+        using P = std::pair<T, U>;
+        using TH = TestHarness<P>;
+
+        std::tuple<T> t1;
+        std::tuple<U> t2;
+
+        TestHarness<P> h;
+        h.construct(std::piecewise_construct, std::move(t1), std::move(t2));
+        P const& p = *h.ptr;
+        assert(p.first.count == 2);
+        assert(p.first.alloc == h.M);
+        assert(p.second.count == 2);
+        assert(p.second.alloc == h.M);
+    }
+    {
+        using T = CountCopiesAllocV2;
+        using U = CountCopies;
+        using P = std::pair<T, U>;
+        using TH = TestHarness<P>;
+
+        std::tuple<T> t1;
+        std::tuple<U> t2;
+
+        TestHarness<P> h;
+        h.construct(std::piecewise_construct, t1, t2);
+        P const& p = *h.ptr;
+        assert(p.first.count == 2);
+        assert(p.first.alloc == h.M);
+        assert(p.second.count == 2);
+    }
+}
diff --git a/test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/db_deallocate.pass.cpp b/test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/db_deallocate.pass.cpp
new file mode 100644
index 000000000000..020133fc4048
--- /dev/null
+++ b/test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/db_deallocate.pass.cpp
@@ -0,0 +1,42 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// T* polymorphic_allocator<T>::deallocate(T*, size_t size)
+
+int AssertCount = 0;
+
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : (void)::AssertCount++)
+#define _LIBCPP_DEBUG 0
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <cassert>
+
+#include "test_memory_resource.hpp"
+
+namespace ex = std::experimental::pmr;
+
+int main()
+{
+    using Alloc = ex::polymorphic_allocator<int>;
+    using Traits = std::allocator_traits<Alloc>;
+    NullResource R;
+    Alloc a(&R);
+    const std::size_t maxSize = Traits::max_size(a);
+
+    a.deallocate(nullptr, maxSize);
+    assert(AssertCount == 0);
+    a.deallocate(nullptr, maxSize + 1);
+    assert(AssertCount == 1);
+}
diff --git a/test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/max_size.pass.cpp b/test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/max_size.pass.cpp
new file mode 100644
index 000000000000..ac685a99be49
--- /dev/null
+++ b/test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/max_size.pass.cpp
@@ -0,0 +1,65 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++experimental
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// EXTENSION
+// std::size_t polymorphic_allocator<T>::max_size() const noexcept
+
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <cassert>
+
+#include "test_memory_resource.hpp"
+
+namespace ex = std::experimental::pmr;
+
+template <std::size_t S>
+std::size_t getMaxSize() {
+    using T = typename std::aligned_storage<S>::type;
+    static_assert(sizeof(T) == S, "Required for test");
+    return ex::polymorphic_allocator<T>{}.max_size();
+}
+
+template <std::size_t S, std::size_t A>
+std::size_t getMaxSize() {
+    using T = typename std::aligned_storage<S, A>::type;
+    static_assert(sizeof(T) == S, "Required for test");
+    return ex::polymorphic_allocator<T>{}.max_size();
+}
+
+int main()
+{
+    {
+        using Alloc = ex::polymorphic_allocator<int>;
+        using Traits = std::allocator_traits<Alloc>;
+        const Alloc a;
+        static_assert(std::is_same<decltype(a.max_size()), Traits::size_type>::value, "");
+        static_assert(noexcept(a.max_size()), "");
+    }
+    {
+        constexpr std::size_t Max = std::numeric_limits<std::size_t>::max();
+        assert(getMaxSize<1>()    == Max);
+        assert(getMaxSize<2>()    == Max / 2);
+        assert(getMaxSize<4>()    == Max / 4);
+        assert(getMaxSize<8>()    == Max / 8);
+        assert(getMaxSize<16>()   == Max / 16);
+        assert(getMaxSize<32>()   == Max / 32);
+        assert(getMaxSize<64>()   == Max / 64);
+        assert(getMaxSize<1024>() == Max / 1024);
+
+        assert((getMaxSize<6,  2>() == Max / 6));
+        assert((getMaxSize<12, 4>() == Max / 12));
+    }
+}
diff --git a/test/libcxx/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/db_deallocate.pass.cpp b/test/libcxx/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/db_deallocate.pass.cpp
new file mode 100644
index 000000000000..ccb9b710e5dc
--- /dev/null
+++ b/test/libcxx/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/db_deallocate.pass.cpp
@@ -0,0 +1,45 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// T* polymorphic_allocator<T>::deallocate(T*, size_t size)
+
+int AssertCount = 0;
+
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : (void)::AssertCount++)
+#define _LIBCPP_DEBUG 0
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <cassert>
+
+#include "test_memory_resource.hpp"
+
+namespace ex = std::experimental::pmr;
+
+int main()
+{
+    using Alloc = NullAllocator<char>;
+    using R = ex::resource_adaptor<Alloc>;
+    AllocController P;
+    ex::resource_adaptor<Alloc> r(Alloc{P});
+    ex::memory_resource & m1 = r;
+
+    std::size_t maxSize = std::numeric_limits<std::size_t>::max()
+                            - alignof(std::max_align_t);
+
+    m1.deallocate(nullptr, maxSize);
+    assert(AssertCount == 0);
+    m1.deallocate(nullptr, maxSize + 1);
+    assert(AssertCount >= 1);
+}
diff --git a/test/libcxx/experimental/memory/memory.resource.aliases/header_deque_libcpp_version.pass.cpp b/test/libcxx/experimental/memory/memory.resource.aliases/header_deque_libcpp_version.pass.cpp
new file mode 100644
index 000000000000..04b361dfe5a4
--- /dev/null
+++ b/test/libcxx/experimental/memory/memory.resource.aliases/header_deque_libcpp_version.pass.cpp
@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/deque>
+
+#include <experimental/deque>
+
+#ifndef _LIBCPP_VERSION
+#error header must provide _LIBCPP_VERSION
+#endif
+
+int main()
+{
+}
diff --git a/test/libcxx/experimental/memory/memory.resource.aliases/header_forward_list_libcpp_version.pass.cpp b/test/libcxx/experimental/memory/memory.resource.aliases/header_forward_list_libcpp_version.pass.cpp
new file mode 100644
index 000000000000..11fc21b3b03c
--- /dev/null
+++ b/test/libcxx/experimental/memory/memory.resource.aliases/header_forward_list_libcpp_version.pass.cpp
@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/forward_list>
+
+#include <experimental/forward_list>
+
+#ifndef _LIBCPP_VERSION
+#error header must provide _LIBCPP_VERSION
+#endif
+
+int main()
+{
+}
diff --git a/test/libcxx/experimental/memory/memory.resource.aliases/header_list_libcpp_version.pass.cpp b/test/libcxx/experimental/memory/memory.resource.aliases/header_list_libcpp_version.pass.cpp
new file mode 100644
index 000000000000..9a72979e0af0
--- /dev/null
+++ b/test/libcxx/experimental/memory/memory.resource.aliases/header_list_libcpp_version.pass.cpp
@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/list>
+
+#include <experimental/list>
+
+#ifndef _LIBCPP_VERSION
+#error header must provide _LIBCPP_VERSION
+#endif
+
+int main()
+{
+}
diff --git a/test/libcxx/experimental/memory/memory.resource.aliases/header_map_libcpp_version.pass.cpp b/test/libcxx/experimental/memory/memory.resource.aliases/header_map_libcpp_version.pass.cpp
new file mode 100644
index 000000000000..24a1bf3042c1
--- /dev/null
+++ b/test/libcxx/experimental/memory/memory.resource.aliases/header_map_libcpp_version.pass.cpp
@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/map>
+
+#include <experimental/map>
+
+#ifndef _LIBCPP_VERSION
+#error header must provide _LIBCPP_VERSION
+#endif
+
+int main()
+{
+}
diff --git a/test/libcxx/experimental/memory/memory.resource.aliases/header_regex_libcpp_version.pass.cpp b/test/libcxx/experimental/memory/memory.resource.aliases/header_regex_libcpp_version.pass.cpp
new file mode 100644
index 000000000000..ff81bc09b850
--- /dev/null
+++ b/test/libcxx/experimental/memory/memory.resource.aliases/header_regex_libcpp_version.pass.cpp
@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/regex>
+
+#include <experimental/regex>
+
+#ifndef _LIBCPP_VERSION
+#error header must provide _LIBCPP_VERSION
+#endif
+
+int main()
+{
+}
diff --git a/test/libcxx/experimental/memory/memory.resource.aliases/header_set_libcpp_version.pass.cpp b/test/libcxx/experimental/memory/memory.resource.aliases/header_set_libcpp_version.pass.cpp
new file mode 100644
index 000000000000..6b02f46b4f73
--- /dev/null
+++ b/test/libcxx/experimental/memory/memory.resource.aliases/header_set_libcpp_version.pass.cpp
@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/set>
+
+#include <experimental/set>
+
+#ifndef _LIBCPP_VERSION
+#error header must provide _LIBCPP_VERSION
+#endif
+
+int main()
+{
+}
diff --git a/test/libcxx/experimental/memory/memory.resource.aliases/header_string_libcpp_version.pass.cpp b/test/libcxx/experimental/memory/memory.resource.aliases/header_string_libcpp_version.pass.cpp
new file mode 100644
index 000000000000..b4b7fdf10f59
--- /dev/null
+++ b/test/libcxx/experimental/memory/memory.resource.aliases/header_string_libcpp_version.pass.cpp
@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/string>
+
+#include <experimental/string>
+
+#ifndef _LIBCPP_VERSION
+#error header must provide _LIBCPP_VERSION
+#endif
+
+int main()
+{
+}
diff --git a/test/libcxx/experimental/memory/memory.resource.aliases/header_unordered_map_libcpp_version.pass.cpp b/test/libcxx/experimental/memory/memory.resource.aliases/header_unordered_map_libcpp_version.pass.cpp
new file mode 100644
index 000000000000..ab9cc189b73d
--- /dev/null
+++ b/test/libcxx/experimental/memory/memory.resource.aliases/header_unordered_map_libcpp_version.pass.cpp
@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/unordered_map>
+
+#include <experimental/unordered_map>
+
+#ifndef _LIBCPP_VERSION
+#error header must provide _LIBCPP_VERSION
+#endif
+
+int main()
+{
+}
diff --git a/test/libcxx/experimental/memory/memory.resource.aliases/header_unordered_set_libcpp_version.pass.cpp b/test/libcxx/experimental/memory/memory.resource.aliases/header_unordered_set_libcpp_version.pass.cpp
new file mode 100644
index 000000000000..37533c7fd87c
--- /dev/null
+++ b/test/libcxx/experimental/memory/memory.resource.aliases/header_unordered_set_libcpp_version.pass.cpp
@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/unordered_set>
+
+#include <experimental/unordered_set>
+
+#ifndef _LIBCPP_VERSION
+#error header must provide _LIBCPP_VERSION
+#endif
+
+int main()
+{
+}
diff --git a/test/libcxx/experimental/memory/memory.resource.aliases/header_vector_libcpp_version.pass.cpp b/test/libcxx/experimental/memory/memory.resource.aliases/header_vector_libcpp_version.pass.cpp
new file mode 100644
index 000000000000..103d32becf9c
--- /dev/null
+++ b/test/libcxx/experimental/memory/memory.resource.aliases/header_vector_libcpp_version.pass.cpp
@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/vector>
+
+#include <experimental/vector>
+
+#ifndef _LIBCPP_VERSION
+#error header must provide _LIBCPP_VERSION
+#endif
+
+int main()
+{
+}
diff --git a/test/libcxx/experimental/memory/memory.resource.global/global_memory_resource_lifetime.pass.cpp b/test/libcxx/experimental/memory/memory.resource.global/global_memory_resource_lifetime.pass.cpp
new file mode 100644
index 000000000000..341a88c0bab1
--- /dev/null
+++ b/test/libcxx/experimental/memory/memory.resource.global/global_memory_resource_lifetime.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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++experimental
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/memory_resource>
+
+// memory_resource * new_delete_resource()
+
+// The lifetime of the value returned by 'new_delete_resource()' should
+// never end, even very late into program termination. This test constructs
+// attempts to use 'new_delete_resource()' very late in program termination
+// to detect lifetime issues.
+
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <cassert>
+
+namespace ex = std::experimental::pmr;
+
+struct POSType {
+  ex::memory_resource* res = nullptr;
+  void* ptr = nullptr;
+  int n = 0;
+  POSType() {}
+  POSType(ex::memory_resource* r, void* p, int s) : res(r), ptr(p), n(s) {}
+  ~POSType() {
+      if (ptr) {
+          if (!res) res = ex::get_default_resource();
+          res->deallocate(ptr, n);
+      }
+  }
+};
+
+void swap(POSType & L, POSType & R) {
+    std::swap(L.res, R.res);
+    std::swap(L.ptr, R.ptr);
+    std::swap(L.n, R.n);
+}
+
+POSType constructed_before_resources;
+POSType constructed_before_resources2;
+
+// Constructs resources
+ex::memory_resource* resource = ex::get_default_resource();
+
+POSType constructed_after_resources(resource, resource->allocate(1024), 1024);
+POSType constructed_after_resources2(nullptr, resource->allocate(1024), 1024);
+
+int main()
+{
+    swap(constructed_after_resources, constructed_before_resources);
+    swap(constructed_before_resources2, constructed_after_resources2);
+}
diff --git a/test/libcxx/experimental/memory/memory.resource.global/new_delete_resource_lifetime.pass.cpp b/test/libcxx/experimental/memory/memory.resource.global/new_delete_resource_lifetime.pass.cpp
new file mode 100644
index 000000000000..9b92d02bc437
--- /dev/null
+++ b/test/libcxx/experimental/memory/memory.resource.global/new_delete_resource_lifetime.pass.cpp
@@ -0,0 +1,53 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++experimental
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/memory_resource>
+
+// memory_resource * new_delete_resource()
+
+// The lifetime of the value returned by 'new_delete_resource()' should
+// never end, even very late into program termination. This test constructs
+// attempts to use 'new_delete_resource()' very late in program termination
+// to detect lifetime issues.
+
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <cassert>
+
+namespace ex = std::experimental::pmr;
+
+struct POSType {
+  ex::memory_resource* res = nullptr;
+  void* ptr = nullptr;
+  int n = 0;
+  POSType() {res = ex::new_delete_resource(); ptr = res->allocate(42); n = 42; }
+  POSType(ex::memory_resource* r, void* p, int s) : res(r), ptr(p), n(s) {}
+  ~POSType() { if (ptr) res->deallocate(ptr, n); }
+};
+
+void swap(POSType & L, POSType & R) {
+    std::swap(L.res, R.res);
+    std::swap(L.ptr, R.ptr);
+    std::swap(L.n, R.n);
+}
+
+POSType constructed_before_resources;
+
+// Constructs resources
+ex::memory_resource* resource = ex::new_delete_resource();
+
+POSType constructed_after_resources(resource, resource->allocate(1024), 1024);
+
+int main()
+{
+    swap(constructed_after_resources, constructed_before_resources);
+}
diff --git a/test/libcxx/experimental/memory/memory.resource.synop/version.pass.cpp b/test/libcxx/experimental/memory/memory.resource.synop/version.pass.cpp
new file mode 100644
index 000000000000..d05575e8849e
--- /dev/null
+++ b/test/libcxx/experimental/memory/memory.resource.synop/version.pass.cpp
@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/memory_resource>
+
+#include <experimental/memory_resource>
+
+#ifndef _LIBCPP_VERSION
+#error _LIBCPP_VERSION not defined
+#endif
+
+int main()
+{
+}
diff --git a/test/std/experimental/optional/version.pass.cpp b/test/libcxx/experimental/optional/version.pass.cpp
index 585b7a24eea5..585b7a24eea5 100644
--- a/test/std/experimental/optional/version.pass.cpp
+++ b/test/libcxx/experimental/optional/version.pass.cpp
diff --git a/test/std/experimental/utilities/meta/version.pass.cpp b/test/libcxx/experimental/utilities/meta/version.pass.cpp
index 593fb52a4c3b..593fb52a4c3b 100644
--- a/test/std/experimental/utilities/meta/version.pass.cpp
+++ b/test/libcxx/experimental/utilities/meta/version.pass.cpp
diff --git a/test/libcxx/experimental/utilities/ratio/header.ratio.synop/includes.pass.cpp b/test/libcxx/experimental/utilities/ratio/header.ratio.synop/includes.pass.cpp
index db9026aebd84..ea7ef6cbc108 100644
--- a/test/libcxx/experimental/utilities/ratio/header.ratio.synop/includes.pass.cpp
+++ b/test/libcxx/experimental/utilities/ratio/header.ratio.synop/includes.pass.cpp
@@ -7,16 +7,15 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <experimental/ratio>
 
 // Test that <ratio> is included.
 
 #include <experimental/ratio>
 
-#if _LIBCPP_STD_VER > 11
-# ifndef _LIBCPP_RATIO
-#   error " <experimental/ratio> must include <ratio>"
-# endif
+#ifndef _LIBCPP_RATIO
+#  error " <experimental/ratio> must include <ratio>"
 #endif
 
 int main()
diff --git a/test/libcxx/experimental/utilities/syserror/header.system_error.synop/includes.pass.cpp b/test/libcxx/experimental/utilities/syserror/header.system_error.synop/includes.pass.cpp
index 88c7458395d4..be3aacdc362c 100644
--- a/test/libcxx/experimental/utilities/syserror/header.system_error.synop/includes.pass.cpp
+++ b/test/libcxx/experimental/utilities/syserror/header.system_error.synop/includes.pass.cpp
@@ -7,14 +7,13 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <experimental/system_error>
 
 #include <experimental/system_error>
 
-#if _LIBCPP_STD_VER > 11
-# ifndef _LIBCPP_SYSTEM_ERROR
-#   error "<experimental/system_error> must include <system_error>"
-# endif
+#ifndef _LIBCPP_SYSTEM_ERROR
+#  error "<experimental/system_error> must include <system_error>"
 #endif
 
 int main()
diff --git a/test/libcxx/experimental/utilities/time/header.chrono.synop/includes.pass.cpp b/test/libcxx/experimental/utilities/time/header.chrono.synop/includes.pass.cpp
index ad4a79105b0b..e91068c742e1 100644
--- a/test/libcxx/experimental/utilities/time/header.chrono.synop/includes.pass.cpp
+++ b/test/libcxx/experimental/utilities/time/header.chrono.synop/includes.pass.cpp
@@ -7,14 +7,13 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <experimental/chrono>
 
 #include <experimental/chrono>
 
-#if _LIBCPP_STD_VER > 11
-# ifndef _LIBCPP_CHRONO
-#   error "<experimental/chrono> must include <chrono>"
-# endif
+#ifndef _LIBCPP_CHRONO
+#  error "<experimental/chrono> must include <chrono>"
 #endif
 
 int main()
diff --git a/test/libcxx/experimental/utilities/tuple/header.tuple.synop/includes.pass.cpp b/test/libcxx/experimental/utilities/tuple/header.tuple.synop/includes.pass.cpp
index 544ddfb269f2..defa454d68f7 100644
--- a/test/libcxx/experimental/utilities/tuple/header.tuple.synop/includes.pass.cpp
+++ b/test/libcxx/experimental/utilities/tuple/header.tuple.synop/includes.pass.cpp
@@ -7,15 +7,14 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <experimental/tuple>
 
 #include <experimental/tuple>
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
-# ifndef _LIBCPP_TUPLE
-#   error "<experimental/tuple> must include <tuple>"
-# endif
-#endif /* _LIBCPP_STD_VER > 11 */
+#ifndef _LIBCPP_TUPLE
+#  error "<experimental/tuple> must include <tuple>"
+#endif
 }
diff --git a/test/std/experimental/utilities/utility/version.pass.cpp b/test/libcxx/experimental/utilities/utility/version.pass.cpp
index 437712454ae5..437712454ae5 100644
--- a/test/std/experimental/utilities/utility/version.pass.cpp
+++ b/test/libcxx/experimental/utilities/utility/version.pass.cpp
diff --git a/test/std/extensions/hash/specializations.fail.cpp b/test/libcxx/extensions/hash/specializations.fail.cpp
index 8eeffb5802e7..8eeffb5802e7 100644
--- a/test/std/extensions/hash/specializations.fail.cpp
+++ b/test/libcxx/extensions/hash/specializations.fail.cpp
diff --git a/test/std/extensions/hash/specializations.pass.cpp b/test/libcxx/extensions/hash/specializations.pass.cpp
index a222b1eb5c6d..a222b1eb5c6d 100644
--- a/test/std/extensions/hash/specializations.pass.cpp
+++ b/test/libcxx/extensions/hash/specializations.pass.cpp
diff --git a/test/std/extensions/hash_map/const_iterator.fail.cpp b/test/libcxx/extensions/hash_map/const_iterator.fail.cpp
index e4c536e8f33a..e4c536e8f33a 100644
--- a/test/std/extensions/hash_map/const_iterator.fail.cpp
+++ b/test/libcxx/extensions/hash_map/const_iterator.fail.cpp
diff --git a/test/std/extensions/nothing_to_do.pass.cpp b/test/libcxx/extensions/nothing_to_do.pass.cpp
index b58f5c55b643..b58f5c55b643 100644
--- a/test/std/extensions/nothing_to_do.pass.cpp
+++ b/test/libcxx/extensions/nothing_to_do.pass.cpp
diff --git a/test/std/input.output/file.streams/c.files/version_ccstdio.pass.cpp b/test/libcxx/input.output/file.streams/c.files/version_ccstdio.pass.cpp
index 0d7fc5605324..0d7fc5605324 100644
--- a/test/std/input.output/file.streams/c.files/version_ccstdio.pass.cpp
+++ b/test/libcxx/input.output/file.streams/c.files/version_ccstdio.pass.cpp
diff --git a/test/std/input.output/file.streams/c.files/version_cinttypes.pass.cpp b/test/libcxx/input.output/file.streams/c.files/version_cinttypes.pass.cpp
index bfd379e43493..bfd379e43493 100644
--- a/test/std/input.output/file.streams/c.files/version_cinttypes.pass.cpp
+++ b/test/libcxx/input.output/file.streams/c.files/version_cinttypes.pass.cpp
diff --git a/test/std/input.output/file.streams/fstreams/version.pass.cpp b/test/libcxx/input.output/file.streams/fstreams/version.pass.cpp
index 44b851416808..44b851416808 100644
--- a/test/std/input.output/file.streams/fstreams/version.pass.cpp
+++ b/test/libcxx/input.output/file.streams/fstreams/version.pass.cpp
diff --git a/test/std/input.output/iostream.format/input.streams/version.pass.cpp b/test/libcxx/input.output/iostream.format/input.streams/version.pass.cpp
index b03ef2aaa04e..b03ef2aaa04e 100644
--- a/test/std/input.output/iostream.format/input.streams/version.pass.cpp
+++ b/test/libcxx/input.output/iostream.format/input.streams/version.pass.cpp
diff --git a/test/std/input.output/iostream.format/output.streams/version.pass.cpp b/test/libcxx/input.output/iostream.format/output.streams/version.pass.cpp
index 662b6987b3c8..662b6987b3c8 100644
--- a/test/std/input.output/iostream.format/output.streams/version.pass.cpp
+++ b/test/libcxx/input.output/iostream.format/output.streams/version.pass.cpp
diff --git a/test/std/input.output/iostream.format/std.manip/version.pass.cpp b/test/libcxx/input.output/iostream.format/std.manip/version.pass.cpp
index ca4fd3d463ee..ca4fd3d463ee 100644
--- a/test/std/input.output/iostream.format/std.manip/version.pass.cpp
+++ b/test/libcxx/input.output/iostream.format/std.manip/version.pass.cpp
diff --git a/test/std/input.output/iostream.forward/version.pass.cpp b/test/libcxx/input.output/iostream.forward/version.pass.cpp
index cf91332d5597..cf91332d5597 100644
--- a/test/std/input.output/iostream.forward/version.pass.cpp
+++ b/test/libcxx/input.output/iostream.forward/version.pass.cpp
diff --git a/test/std/input.output/iostream.objects/version.pass.cpp b/test/libcxx/input.output/iostream.objects/version.pass.cpp
index 09b3611f6df9..09b3611f6df9 100644
--- a/test/std/input.output/iostream.objects/version.pass.cpp
+++ b/test/libcxx/input.output/iostream.objects/version.pass.cpp
diff --git a/test/std/input.output/iostreams.base/version.pass.cpp b/test/libcxx/input.output/iostreams.base/version.pass.cpp
index f56846d38b8d..f56846d38b8d 100644
--- a/test/std/input.output/iostreams.base/version.pass.cpp
+++ b/test/libcxx/input.output/iostreams.base/version.pass.cpp
diff --git a/test/std/input.output/stream.buffers/version.pass.cpp b/test/libcxx/input.output/stream.buffers/version.pass.cpp
index c4b06be60187..c4b06be60187 100644
--- a/test/std/input.output/stream.buffers/version.pass.cpp
+++ b/test/libcxx/input.output/stream.buffers/version.pass.cpp
diff --git a/test/std/input.output/string.streams/version.pass.cpp b/test/libcxx/input.output/string.streams/version.pass.cpp
index 103897106d37..103897106d37 100644
--- a/test/std/input.output/string.streams/version.pass.cpp
+++ b/test/libcxx/input.output/string.streams/version.pass.cpp
diff --git a/test/libcxx/iterators/trivial_iterators.pass.cpp b/test/libcxx/iterators/trivial_iterators.pass.cpp
index 0b7a47316d65..33c830251769 100644
--- a/test/libcxx/iterators/trivial_iterators.pass.cpp
+++ b/test/libcxx/iterators/trivial_iterators.pass.cpp
@@ -13,7 +13,7 @@
 // __libcpp_is_trivial_iterator<Tp>
 
 // __libcpp_is_trivial_iterator determines if an iterator is a "trivial" one,
-// that can be used w/o worrying about its operations throwing exceptions. 
+// that can be used w/o worrying about its operations throwing exceptions.
 // Pointers are trivial iterators. Libc++ has three "iterator wrappers":
 // reverse_iterator, move_iterator, and __wrap_iter. If the underlying iterator
 // is trivial, then those are as well.
@@ -113,16 +113,16 @@ int main()
     static_assert(( std::__libcpp_is_trivial_iterator<std::__wrap_iter<int *> >       ::value), "");
     static_assert(( std::__libcpp_is_trivial_iterator<std::__wrap_iter<T *> >         ::value), "");
 
-    static_assert(( std::__libcpp_is_trivial_iterator<std::reverse_iterator<std::__wrap_iter<char *> > > ::value), ""); 
-    
+    static_assert(( std::__libcpp_is_trivial_iterator<std::reverse_iterator<std::__wrap_iter<char *> > > ::value), "");
+
 //  iterators in the libc++ test suite
-    static_assert((!std::__libcpp_is_trivial_iterator<output_iterator       <char *> >::value), "");    
-    static_assert((!std::__libcpp_is_trivial_iterator<input_iterator        <char *> >::value), "");    
-    static_assert((!std::__libcpp_is_trivial_iterator<forward_iterator      <char *> >::value), "");    
-    static_assert((!std::__libcpp_is_trivial_iterator<bidirectional_iterator<char *> >::value), "");    
-    static_assert((!std::__libcpp_is_trivial_iterator<random_access_iterator<char *> >::value), "");    
-    static_assert((!std::__libcpp_is_trivial_iterator<ThrowingIterator      <char *> >::value), "");    
-    static_assert((!std::__libcpp_is_trivial_iterator<NonThrowingIterator   <char *> >::value), "");    
+    static_assert((!std::__libcpp_is_trivial_iterator<output_iterator       <char *> >::value), "");
+    static_assert((!std::__libcpp_is_trivial_iterator<input_iterator        <char *> >::value), "");
+    static_assert((!std::__libcpp_is_trivial_iterator<forward_iterator      <char *> >::value), "");
+    static_assert((!std::__libcpp_is_trivial_iterator<bidirectional_iterator<char *> >::value), "");
+    static_assert((!std::__libcpp_is_trivial_iterator<random_access_iterator<char *> >::value), "");
+    static_assert((!std::__libcpp_is_trivial_iterator<ThrowingIterator      <char *> >::value), "");
+    static_assert((!std::__libcpp_is_trivial_iterator<NonThrowingIterator   <char *> >::value), "");
 
 
 //	Iterator classification
@@ -137,7 +137,7 @@ int main()
 	static_assert((!std::__is_bidirectional_iterator<input_iterator<char *> >::value), "" );
 	static_assert((!std::__is_random_access_iterator<input_iterator<char *> >::value), "" );
 	static_assert(( std::__is_exactly_input_iterator<input_iterator<char *> >::value), "" );
-	
+
 	static_assert(( std::__is_input_iterator        <forward_iterator<char *> >::value), "" );
 	static_assert(( std::__is_forward_iterator      <forward_iterator<char *> >::value), "" );
 	static_assert((!std::__is_bidirectional_iterator<forward_iterator<char *> >::value), "" );
@@ -171,7 +171,7 @@ int main()
     static_assert(( std::__libcpp_is_trivial_iterator<std::vector<char>::const_iterator>        ::value), "");
     static_assert(( std::__libcpp_is_trivial_iterator<std::vector<char>::reverse_iterator>      ::value), "");
     static_assert(( std::__libcpp_is_trivial_iterator<std::vector<char>::const_reverse_iterator>::value), "");
-    
+
 //  vector
     static_assert(( std::__libcpp_is_trivial_iterator<std::basic_string<char>::iterator>              ::value), "");
     static_assert(( std::__libcpp_is_trivial_iterator<std::basic_string<char>::const_iterator>        ::value), "");
diff --git a/test/std/iterators/version.pass.cpp b/test/libcxx/iterators/version.pass.cpp
index dd097850388e..dd097850388e 100644
--- a/test/std/iterators/version.pass.cpp
+++ b/test/libcxx/iterators/version.pass.cpp
diff --git a/test/std/language.support/cstdint/version.pass.cpp b/test/libcxx/language.support/cstdint/version.pass.cpp
index 4c9a43a62abc..4c9a43a62abc 100644
--- a/test/std/language.support/cstdint/version.pass.cpp
+++ b/test/libcxx/language.support/cstdint/version.pass.cpp
diff --git a/test/std/language.support/support.dynamic/alloc.errors/new.badlength/bad_array_length.pass.cpp b/test/libcxx/language.support/support.dynamic/alloc.errors/new.badlength/bad_array_length.pass.cpp
index 7de503304556..cc99b83aca4e 100644
--- a/test/std/language.support/support.dynamic/alloc.errors/new.badlength/bad_array_length.pass.cpp
+++ b/test/libcxx/language.support/support.dynamic/alloc.errors/new.badlength/bad_array_length.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // test bad_array_length
 
 #include <new>
@@ -15,7 +16,6 @@
 
 int main()
 {
-#if __LIBCPP_STD_VER > 11
     static_assert((std::is_base_of<std::bad_alloc, std::bad_array_length>::value),
                   "std::is_base_of<std::bad_alloc, std::bad_array_length>::value");
     static_assert(std::is_polymorphic<std::bad_array_length>::value,
@@ -25,5 +25,4 @@ int main()
     b2 = b;
     const char* w = b2.what();
     assert(w);
-#endif
 }
diff --git a/test/std/language.support/support.dynamic/version.pass.cpp b/test/libcxx/language.support/support.dynamic/version.pass.cpp
index ba1ff518e51f..ba1ff518e51f 100644
--- a/test/std/language.support/support.dynamic/version.pass.cpp
+++ b/test/libcxx/language.support/support.dynamic/version.pass.cpp
diff --git a/test/std/language.support/support.exception/version.pass.cpp b/test/libcxx/language.support/support.exception/version.pass.cpp
index acdedbb31fe3..acdedbb31fe3 100644
--- a/test/std/language.support/support.exception/version.pass.cpp
+++ b/test/libcxx/language.support/support.exception/version.pass.cpp
diff --git a/test/std/language.support/support.initlist/version.pass.cpp b/test/libcxx/language.support/support.initlist/version.pass.cpp
index f3f08cd1f864..f3f08cd1f864 100644
--- a/test/std/language.support/support.initlist/version.pass.cpp
+++ b/test/libcxx/language.support/support.initlist/version.pass.cpp
diff --git a/test/std/language.support/support.limits/c.limits/version_cfloat.pass.cpp b/test/libcxx/language.support/support.limits/c.limits/version_cfloat.pass.cpp
index 19b463199cd6..19b463199cd6 100644
--- a/test/std/language.support/support.limits/c.limits/version_cfloat.pass.cpp
+++ b/test/libcxx/language.support/support.limits/c.limits/version_cfloat.pass.cpp
diff --git a/test/std/language.support/support.limits/c.limits/version_climits.pass.cpp b/test/libcxx/language.support/support.limits/c.limits/version_climits.pass.cpp
index 3fe07a5174b3..3fe07a5174b3 100644
--- a/test/std/language.support/support.limits/c.limits/version_climits.pass.cpp
+++ b/test/libcxx/language.support/support.limits/c.limits/version_climits.pass.cpp
diff --git a/test/std/language.support/support.limits/limits/version.pass.cpp b/test/libcxx/language.support/support.limits/limits/version.pass.cpp
index 0cb3f6f52a4e..0cb3f6f52a4e 100644
--- a/test/std/language.support/support.limits/limits/version.pass.cpp
+++ b/test/libcxx/language.support/support.limits/limits/version.pass.cpp
diff --git a/test/std/language.support/support.rtti/version.pass.cpp b/test/libcxx/language.support/support.rtti/version.pass.cpp
index 0a9ece34f97e..0a9ece34f97e 100644
--- a/test/std/language.support/support.rtti/version.pass.cpp
+++ b/test/libcxx/language.support/support.rtti/version.pass.cpp
diff --git a/test/std/language.support/support.runtime/version_csetjmp.pass.cpp b/test/libcxx/language.support/support.runtime/version_csetjmp.pass.cpp
index 7e37716d0145..7e37716d0145 100644
--- a/test/std/language.support/support.runtime/version_csetjmp.pass.cpp
+++ b/test/libcxx/language.support/support.runtime/version_csetjmp.pass.cpp
diff --git a/test/std/language.support/support.runtime/version_csignal.pass.cpp b/test/libcxx/language.support/support.runtime/version_csignal.pass.cpp
index be1045f1eb3b..be1045f1eb3b 100644
--- a/test/std/language.support/support.runtime/version_csignal.pass.cpp
+++ b/test/libcxx/language.support/support.runtime/version_csignal.pass.cpp
diff --git a/test/std/language.support/support.runtime/version_cstdarg.pass.cpp b/test/libcxx/language.support/support.runtime/version_cstdarg.pass.cpp
index f3ca9389b15d..f3ca9389b15d 100644
--- a/test/std/language.support/support.runtime/version_cstdarg.pass.cpp
+++ b/test/libcxx/language.support/support.runtime/version_cstdarg.pass.cpp
diff --git a/test/std/language.support/support.runtime/version_cstdbool.pass.cpp b/test/libcxx/language.support/support.runtime/version_cstdbool.pass.cpp
index 0415227e58ea..0415227e58ea 100644
--- a/test/std/language.support/support.runtime/version_cstdbool.pass.cpp
+++ b/test/libcxx/language.support/support.runtime/version_cstdbool.pass.cpp
diff --git a/test/std/language.support/support.runtime/version_cstdlib.pass.cpp b/test/libcxx/language.support/support.runtime/version_cstdlib.pass.cpp
index db419524f578..db419524f578 100644
--- a/test/std/language.support/support.runtime/version_cstdlib.pass.cpp
+++ b/test/libcxx/language.support/support.runtime/version_cstdlib.pass.cpp
diff --git a/test/std/language.support/support.runtime/version_ctime.pass.cpp b/test/libcxx/language.support/support.runtime/version_ctime.pass.cpp
index ce0bf2cf1853..ce0bf2cf1853 100644
--- a/test/std/language.support/support.runtime/version_ctime.pass.cpp
+++ b/test/libcxx/language.support/support.runtime/version_ctime.pass.cpp
diff --git a/test/std/language.support/support.types/version.pass.cpp b/test/libcxx/language.support/support.types/version.pass.cpp
index 2ab7c188de1d..2ab7c188de1d 100644
--- a/test/std/language.support/support.types/version.pass.cpp
+++ b/test/libcxx/language.support/support.types/version.pass.cpp
diff --git a/test/std/localization/c.locales/version.pass.cpp b/test/libcxx/localization/c.locales/version.pass.cpp
index 0fce59e2b0b8..0fce59e2b0b8 100644
--- a/test/std/localization/c.locales/version.pass.cpp
+++ b/test/libcxx/localization/c.locales/version.pass.cpp
diff --git a/test/std/localization/locale.categories/__scan_keyword.pass.cpp b/test/libcxx/localization/locale.categories/__scan_keyword.pass.cpp
index b33aab9a730a..b33aab9a730a 100644
--- a/test/std/localization/locale.categories/__scan_keyword.pass.cpp
+++ b/test/libcxx/localization/locale.categories/__scan_keyword.pass.cpp
diff --git a/test/std/localization/locale.stdcvt/version.pass.cpp b/test/libcxx/localization/locale.stdcvt/version.pass.cpp
index 3885380854cc..3885380854cc 100644
--- a/test/std/localization/locale.stdcvt/version.pass.cpp
+++ b/test/libcxx/localization/locale.stdcvt/version.pass.cpp
diff --git a/test/libcxx/localization/locales/locale.convenience/conversions/conversions.string/ctor_move.pass.cpp b/test/libcxx/localization/locales/locale.convenience/conversions/conversions.string/ctor_move.pass.cpp
new file mode 100644
index 000000000000..75e2aeb064eb
--- /dev/null
+++ b/test/libcxx/localization/locales/locale.convenience/conversions/conversions.string/ctor_move.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
+
+// <locale>
+
+// wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc>
+
+// wstring_convert(wstring_convert&& other); // EXTENSION
+
+#include <locale>
+#include <codecvt>
+#include <cassert>
+
+int main()
+{
+    typedef std::codecvt_utf8<wchar_t> Codecvt;
+    typedef std::wstring_convert<Codecvt> Myconv;
+    // create a converter and perform some conversions to generate some
+    // interesting state.
+    Myconv myconv;
+    myconv.from_bytes("\xF1\x80\x80\x83");
+    const int old_converted = myconv.converted();
+    assert(myconv.converted() == 4);
+    // move construct a new converter and make sure the state is the same.
+    Myconv myconv2(std::move(myconv));
+    assert(myconv2.converted() == 4);
+}
diff --git a/test/std/localization/locales/locale/locale.types/locale.facet/facet.pass.cpp b/test/libcxx/localization/locales/locale/locale.types/locale.facet/facet.pass.cpp
index 4a7f77ad5d9a..4a7f77ad5d9a 100644
--- a/test/std/localization/locales/locale/locale.types/locale.facet/facet.pass.cpp
+++ b/test/libcxx/localization/locales/locale/locale.types/locale.facet/facet.pass.cpp
diff --git a/test/std/localization/locales/locale/locale.types/locale.id/id.pass.cpp b/test/libcxx/localization/locales/locale/locale.types/locale.id/id.pass.cpp
index 3233624d87b4..3233624d87b4 100644
--- a/test/std/localization/locales/locale/locale.types/locale.id/id.pass.cpp
+++ b/test/libcxx/localization/locales/locale/locale.types/locale.id/id.pass.cpp
diff --git a/test/std/localization/version.pass.cpp b/test/libcxx/localization/version.pass.cpp
index a64534c9f58b..a64534c9f58b 100644
--- a/test/std/localization/version.pass.cpp
+++ b/test/libcxx/localization/version.pass.cpp
diff --git a/test/std/numerics/cfenv/version.pass.cpp b/test/libcxx/numerics/cfenv/version.pass.cpp
index 727d5bdf3994..727d5bdf3994 100644
--- a/test/std/numerics/cfenv/version.pass.cpp
+++ b/test/libcxx/numerics/cfenv/version.pass.cpp
diff --git a/test/std/numerics/complex.number/version.pass.cpp b/test/libcxx/numerics/complex.number/version.pass.cpp
index 316cfec739a9..316cfec739a9 100644
--- a/test/std/numerics/complex.number/version.pass.cpp
+++ b/test/libcxx/numerics/complex.number/version.pass.cpp
diff --git a/test/std/numerics/numarray/version.pass.cpp b/test/libcxx/numerics/numarray/version.pass.cpp
index 85457d4329ec..85457d4329ec 100644
--- a/test/std/numerics/numarray/version.pass.cpp
+++ b/test/libcxx/numerics/numarray/version.pass.cpp
diff --git a/test/std/numerics/numeric.ops/version.pass.cpp b/test/libcxx/numerics/numeric.ops/version.pass.cpp
index fb6e0a1063ce..fb6e0a1063ce 100644
--- a/test/std/numerics/numeric.ops/version.pass.cpp
+++ b/test/libcxx/numerics/numeric.ops/version.pass.cpp
diff --git a/test/std/numerics/rand/rand.synopsis/version.pass.cpp b/test/libcxx/numerics/rand/rand.synopsis/version.pass.cpp
index eae6c493e919..eae6c493e919 100644
--- a/test/std/numerics/rand/rand.synopsis/version.pass.cpp
+++ b/test/libcxx/numerics/rand/rand.synopsis/version.pass.cpp
diff --git a/test/libcxx/selftest/test_macros.pass.cpp b/test/libcxx/selftest/test_macros.pass.cpp
index 2c8ed4f454a7..69e75b788711 100644
--- a/test/libcxx/selftest/test_macros.pass.cpp
+++ b/test/libcxx/selftest/test_macros.pass.cpp
@@ -8,51 +8,59 @@
 //===----------------------------------------------------------------------===//
 //
 // Test the "test_macros.h" header.
+#include <__config>
 #include "test_macros.h"
 
 #ifndef TEST_STD_VER
 #error TEST_STD_VER must be defined
 #endif
 
-#ifndef TEST_DECLTYPE
-#error TEST_DECLTYPE must be defined
-#endif
-
 #ifndef TEST_NOEXCEPT
 #error TEST_NOEXCEPT must be defined
 #endif
 
-#ifndef TEST_STATIC_ASSERT
-#error TEST_STATIC_ASSERT must be defined
+#ifndef LIBCPP_ASSERT
+#error LIBCPP_ASSERT must be defined
 #endif
 
-template <class T, class U>
-struct is_same { enum { value = 0 }; };
-
-template <class T>
-struct is_same<T, T> { enum { value = 1 }; };
-
-int foo() { return 0; }
+#ifndef LIBCPP_STATIC_ASSERT
+#error LIBCPP_STATIC_ASSERT must be defined
+#endif
 
 void test_noexcept() TEST_NOEXCEPT
 {
 }
 
-void test_decltype()
+void test_libcxx_macros()
 {
-  typedef TEST_DECLTYPE(foo()) MyType;
-  TEST_STATIC_ASSERT((is_same<MyType, int>::value), "is same");
-}
+//  ===== C++14 features =====
+//  defined(TEST_HAS_EXTENDED_CONSTEXPR)  != defined(_LIBCPP_HAS_NO_CXX14_CONSTEXPR)
+#ifdef TEST_HAS_EXTENDED_CONSTEXPR
+# ifdef _LIBCPP_HAS_NO_CXX14_CONSTEXPR
+#  error "TEST_EXTENDED_CONSTEXPR mismatch (1)"
+# endif
+#else
+# ifndef _LIBCPP_HAS_NO_CXX14_CONSTEXPR
+#  error "TEST_EXTENDED_CONSTEXPR mismatch (2)"
+# endif
+#endif
 
-void test_static_assert()
-{
-    TEST_STATIC_ASSERT((is_same<int, int>::value), "is same");
-    TEST_STATIC_ASSERT((!is_same<int, long>::value), "not same");
+//  defined(TEST_HAS_VARIABLE_TEMPLATES) != defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
+#ifdef TEST_HAS_VARIABLE_TEMPLATES
+# ifdef _LIBCPP_HAS_NO_VARIABLE_TEMPLATES
+#  error "TEST_VARIABLE_TEMPLATES mismatch (1)"
+# endif
+#else
+# ifndef _LIBCPP_HAS_NO_VARIABLE_TEMPLATES
+#  error "TEST_VARIABLE_TEMPLATES mismatch (2)"
+# endif
+#endif
+
+//  ===== C++1z features =====
 }
 
 int main()
 {
     test_noexcept();
-    test_decltype();
-    test_static_assert();
+    test_libcxx_macros();
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_erase/erase_iter_db1.pass.cpp b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db1.pass.cpp
index 6c2929d7f1d3..6c2929d7f1d3 100644
--- a/test/std/strings/basic.string/string.modifiers/string_erase/erase_iter_db1.pass.cpp
+++ b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db1.pass.cpp
diff --git a/test/std/strings/basic.string/string.modifiers/string_erase/erase_iter_db2.pass.cpp b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db2.pass.cpp
index d20fcd4623b7..d20fcd4623b7 100644
--- a/test/std/strings/basic.string/string.modifiers/string_erase/erase_iter_db2.pass.cpp
+++ b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db2.pass.cpp
diff --git a/test/std/strings/basic.string/string.modifiers/string_erase/erase_iter_iter_db1.pass.cpp b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db1.pass.cpp
index 5015241ad63e..5015241ad63e 100644
--- a/test/std/strings/basic.string/string.modifiers/string_erase/erase_iter_iter_db1.pass.cpp
+++ b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db1.pass.cpp
diff --git a/test/std/strings/basic.string/string.modifiers/string_erase/erase_iter_iter_db2.pass.cpp b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db2.pass.cpp
index 6a23bf88ca5c..6a23bf88ca5c 100644
--- a/test/std/strings/basic.string/string.modifiers/string_erase/erase_iter_iter_db2.pass.cpp
+++ b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db2.pass.cpp
diff --git a/test/std/strings/basic.string/string.modifiers/string_erase/erase_iter_iter_db3.pass.cpp b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db3.pass.cpp
index a8443818aea5..a8443818aea5 100644
--- a/test/std/strings/basic.string/string.modifiers/string_erase/erase_iter_iter_db3.pass.cpp
+++ b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db3.pass.cpp
diff --git a/test/std/strings/basic.string/string.modifiers/string_erase/erase_iter_iter_db4.pass.cpp b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db4.pass.cpp
index 0549e816b44c..0549e816b44c 100644
--- a/test/std/strings/basic.string/string.modifiers/string_erase/erase_iter_iter_db4.pass.cpp
+++ b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db4.pass.cpp
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type4.fail.cpp b/test/libcxx/strings/basic.string/string.modifiers/erase_pop_back_db1.pass.cpp
index ffc715fe9a5b..8a6c3f0cf38f 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type4.fail.cpp
+++ b/test/libcxx/strings/basic.string/string.modifiers/erase_pop_back_db1.pass.cpp
@@ -7,21 +7,26 @@
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++98, c++03, c++11
+// <string>
 
-#include <tuple>
-#include <string>
-#include <memory>
+// void pop_back();
+
+#if _LIBCPP_DEBUG >= 1
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+#endif
 
+#include <string>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
-#if _LIBCPP_STD_VER > 11
-    typedef std::unique_ptr<int> upint;
-    std::tuple<upint> t(upint(new int(4)));
-    upint p = std::get<upint>(t);
-#else
-#error
+#if _LIBCPP_DEBUG >= 1
+    {
+        std::string s;
+        s.pop_back();
+        assert(false);
+    }
 #endif
 }
diff --git a/test/libcxx/strings/basic.string/string.modifiers/insert_iter_char_db1.pass.cpp b/test/libcxx/strings/basic.string/string.modifiers/insert_iter_char_db1.pass.cpp
new file mode 100644
index 000000000000..fbb26d178997
--- /dev/null
+++ b/test/libcxx/strings/basic.string/string.modifiers/insert_iter_char_db1.pass.cpp
@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <string>
+
+// iterator insert(const_iterator p, charT c);
+
+#if _LIBCPP_DEBUG >= 1
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+#endif
+
+#include <string>
+#include <stdexcept>
+#include <cassert>
+
+
+int main()
+{
+#if _LIBCPP_DEBUG >= 1
+    {
+        typedef std::string S;
+        S s;
+        S s2;
+        s.insert(s2.begin(), '1');
+        assert(false);
+    }
+#endif
+}
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type3.fail.cpp b/test/libcxx/strings/basic.string/string.modifiers/insert_iter_size_char_db1.pass.cpp
index 0a4550f387dc..7ddd2b00d402 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type3.fail.cpp
+++ b/test/libcxx/strings/basic.string/string.modifiers/insert_iter_size_char_db1.pass.cpp
@@ -7,21 +7,25 @@
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++98, c++03, c++11
+// <string>
 
-#include <tuple>
-#include <string>
-#include <complex>
+// iterator insert(const_iterator p, size_type n, charT c);
+
+#if _LIBCPP_DEBUG >= 1
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+#endif
 
+#include <string>
 #include <cassert>
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
-    typedef std::complex<float> cf;
-    auto t1 = std::make_tuple<double, int, std::string, cf, int> ( 42, 21, "Hi", { 1,2 } );
-    assert ( std::get<int>(t1) == 42 ); // two ints here (one at the end)
-#else
-#error
+#if _LIBCPP_DEBUG >= 1
+    {
+        std::string s;
+        std::string s2;
+        s.insert(s2.begin(), 1, 'a');
+        assert(false);
+    }
 #endif
 }
diff --git a/test/std/strings/c.strings/version_cctype.pass.cpp b/test/libcxx/strings/c.strings/version_cctype.pass.cpp
index e0919d9d27b0..e0919d9d27b0 100644
--- a/test/std/strings/c.strings/version_cctype.pass.cpp
+++ b/test/libcxx/strings/c.strings/version_cctype.pass.cpp
diff --git a/test/std/strings/c.strings/version_cstring.pass.cpp b/test/libcxx/strings/c.strings/version_cstring.pass.cpp
index 87e705aec4cc..87e705aec4cc 100644
--- a/test/std/strings/c.strings/version_cstring.pass.cpp
+++ b/test/libcxx/strings/c.strings/version_cstring.pass.cpp
diff --git a/test/std/strings/c.strings/version_cuchar.pass.cpp b/test/libcxx/strings/c.strings/version_cuchar.pass.cpp
index dcfdcc37ac7e..dcfdcc37ac7e 100644
--- a/test/std/strings/c.strings/version_cuchar.pass.cpp
+++ b/test/libcxx/strings/c.strings/version_cuchar.pass.cpp
diff --git a/test/std/strings/c.strings/version_cwchar.pass.cpp b/test/libcxx/strings/c.strings/version_cwchar.pass.cpp
index 72e9855c54e5..72e9855c54e5 100644
--- a/test/std/strings/c.strings/version_cwchar.pass.cpp
+++ b/test/libcxx/strings/c.strings/version_cwchar.pass.cpp
diff --git a/test/std/strings/c.strings/version_cwctype.pass.cpp b/test/libcxx/strings/c.strings/version_cwctype.pass.cpp
index 461482abe765..461482abe765 100644
--- a/test/std/strings/c.strings/version_cwctype.pass.cpp
+++ b/test/libcxx/strings/c.strings/version_cwctype.pass.cpp
diff --git a/test/libcxx/strings/iterators.exceptions.pass.cpp b/test/libcxx/strings/iterators.exceptions.pass.cpp
index 591782b5dd4a..02ec921cc613 100644
--- a/test/libcxx/strings/iterators.exceptions.pass.cpp
+++ b/test/libcxx/strings/iterators.exceptions.pass.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-
+// XFAIL: libcpp-no-exceptions
 // <iterator>
 
 // __libcpp_is_trivial_iterator<Tp>
@@ -23,6 +23,7 @@
 #include <vector>
 #include <initializer_list>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 int main()
@@ -30,17 +31,17 @@ int main()
 //  basic tests
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<char *>::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<const char *>::value), "");
-    
+
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::move_iterator<char *> >      ::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::move_iterator<const char *> >::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::reverse_iterator<char *> >      ::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::reverse_iterator<const char *> >::value), "");
-    
+
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::__wrap_iter<char *> >      ::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::__wrap_iter<const char *> >::value), "");
-    
+
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::reverse_iterator<std::__wrap_iter<char *> > > ::value), "");
-    
+
 //  iterators in the libc++ test suite
     static_assert((!std::__libcpp_string_gets_noexcept_iterator<output_iterator       <char *> >::value), "");
     static_assert((!std::__libcpp_string_gets_noexcept_iterator<input_iterator        <char *> >::value), "");
@@ -48,13 +49,13 @@ int main()
     static_assert((!std::__libcpp_string_gets_noexcept_iterator<bidirectional_iterator<char *> >::value), "");
     static_assert((!std::__libcpp_string_gets_noexcept_iterator<random_access_iterator<char *> >::value), "");
     static_assert((!std::__libcpp_string_gets_noexcept_iterator<ThrowingIterator      <char *> >::value), "");
-    
-#if __has_feature(cxx_noexcept)
+
+#if TEST_STD_VER >= 11
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<NonThrowingIterator   <char *> >::value), "");
 #else
     static_assert((!std::__libcpp_string_gets_noexcept_iterator<NonThrowingIterator   <char *> >::value), "");
 #endif
-	
+
 //
 //  iterators from libc++'s containers
 //
diff --git a/test/libcxx/strings/iterators.noexcept.pass.cpp b/test/libcxx/strings/iterators.noexcept.pass.cpp
index f39a4deac735..283cf0897cca 100644
--- a/test/libcxx/strings/iterators.noexcept.pass.cpp
+++ b/test/libcxx/strings/iterators.noexcept.pass.cpp
@@ -34,17 +34,17 @@ int main()
 //  basic tests
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<char *>::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<const char *>::value), "");
-    
+
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::move_iterator<char *> >      ::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::move_iterator<const char *> >::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::reverse_iterator<char *> >      ::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::reverse_iterator<const char *> >::value), "");
-    
+
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::__wrap_iter<char *> >      ::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::__wrap_iter<const char *> >::value), "");
-    
+
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::reverse_iterator<std::__wrap_iter<char *> > > ::value), "");
-    
+
 //  iterators in the libc++ test suite
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<output_iterator       <char *> >::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<input_iterator        <char *> >::value), "");
@@ -52,9 +52,9 @@ int main()
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<bidirectional_iterator<char *> >::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<random_access_iterator<char *> >::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<ThrowingIterator      <char *> >::value), "");
-    
+
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<NonThrowingIterator   <char *> >::value), "");
-	
+
 //
 //  iterators from libc++'s containers
 //
diff --git a/test/std/strings/version.pass.cpp b/test/libcxx/strings/version.pass.cpp
index 0c79c1af2ce8..0c79c1af2ce8 100644
--- a/test/std/strings/version.pass.cpp
+++ b/test/libcxx/strings/version.pass.cpp
diff --git a/test/libcxx/test/config.py b/test/libcxx/test/config.py
index f8096ad15f8a..593f9805447d 100644
--- a/test/libcxx/test/config.py
+++ b/test/libcxx/test/config.py
@@ -61,6 +61,7 @@ class Configuration(object):
         self.libcxx_src_root = None
         self.libcxx_obj_root = None
         self.cxx_library_root = None
+        self.cxx_runtime_root = None
         self.abi_library_root = None
         self.env = {}
         self.use_target = False
@@ -98,9 +99,11 @@ class Configuration(object):
         self.configure_cxx_library_root()
         self.configure_use_system_cxx_lib()
         self.configure_use_clang_verify()
+        self.configure_use_thread_safety()
         self.configure_execute_external()
         self.configure_ccache()
         self.configure_compile_flags()
+        self.configure_filesystem_compile_flags()
         self.configure_link_flags()
         self.configure_env()
         self.configure_color_diagnostics()
@@ -194,6 +197,8 @@ class Configuration(object):
     def configure_cxx_library_root(self):
         self.cxx_library_root = self.get_lit_conf('cxx_library_root',
                                                   self.libcxx_obj_root)
+        self.cxx_runtime_root = self.get_lit_conf('cxx_runtime_root',
+                                                   self.cxx_library_root)
 
     def configure_use_system_cxx_lib(self):
         # This test suite supports testing against either the system library or
@@ -218,6 +223,14 @@ class Configuration(object):
             self.lit_config.note(
                 "inferred use_clang_verify as: %r" % self.use_clang_verify)
 
+    def configure_use_thread_safety(self):
+        '''If set, run clang with -verify on failing tests.'''
+        has_thread_safety = self.cxx.hasCompileFlag('-Werror=thread-safety')
+        if has_thread_safety:
+            self.cxx.compile_flags += ['-Werror=thread-safety']
+            self.config.available_features.add('thread-safety')
+            self.lit_config.note("enabling thread-safety annotations")
+
     def configure_execute_external(self):
         # Choose between lit's internal shell pipeline runner and a real shell.
         # If LIT_USE_INTERNAL_SHELL is in the environment, we use that as the
@@ -277,10 +290,17 @@ class Configuration(object):
         if self.cxx.hasCompileFlag('-fsized-deallocation'):
             self.config.available_features.add('fsized-deallocation')
 
+        if self.get_lit_bool('has_libatomic', False):
+            self.config.available_features.add('libatomic')
+
     def configure_compile_flags(self):
         no_default_flags = self.get_lit_bool('no_default_flags', False)
         if not no_default_flags:
             self.configure_default_compile_flags()
+        # This include is always needed so add so add it regardless of
+        # 'no_default_flags'.
+        support_path = os.path.join(self.libcxx_src_root, 'test/support')
+        self.cxx.compile_flags += ['-I' + support_path]
         # Configure extra flags
         compile_flags_str = self.get_lit_conf('compile_flags', '')
         self.cxx.compile_flags += shlex.split(compile_flags_str)
@@ -329,7 +349,6 @@ class Configuration(object):
 
     def configure_compile_flags_header_includes(self):
         support_path = os.path.join(self.libcxx_src_root, 'test/support')
-        self.cxx.compile_flags += ['-I' + support_path]
         self.cxx.compile_flags += ['-include', os.path.join(support_path, 'nasty_macros.hpp')]
         self.configure_config_site_header()
         libcxx_headers = self.get_lit_conf(
@@ -412,6 +431,37 @@ class Configuration(object):
           self.config.available_features.add('libcpp-abi-unstable')
           self.cxx.compile_flags += ['-D_LIBCPP_ABI_UNSTABLE']
 
+    def configure_filesystem_compile_flags(self):
+        enable_fs = self.get_lit_bool('enable_filesystem', default=False)
+        if not enable_fs:
+            return
+        enable_experimental = self.get_lit_bool('enable_experimental', default=False)
+        if not enable_experimental:
+            self.lit_config.fatal(
+                'filesystem is enabled but libc++experimental.a is not.')
+        self.config.available_features.add('c++filesystem')
+        static_env = os.path.join(self.libcxx_src_root, 'test', 'std',
+                                  'experimental', 'filesystem', 'Inputs', 'static_test_env')
+        static_env = os.path.realpath(static_env)
+        assert os.path.isdir(static_env)
+        self.cxx.compile_flags += ['-DLIBCXX_FILESYSTEM_STATIC_TEST_ROOT="%s"' % static_env]
+
+        dynamic_env = os.path.join(self.libcxx_obj_root, 'test',
+                                   'filesystem', 'Output', 'dynamic_env')
+        dynamic_env = os.path.realpath(dynamic_env)
+        if not os.path.isdir(dynamic_env):
+            os.makedirs(dynamic_env)
+        self.cxx.compile_flags += ['-DLIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT="%s"' % dynamic_env]
+        self.env['LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT'] = ("%s" % dynamic_env)
+
+        dynamic_helper = os.path.join(self.libcxx_src_root, 'test', 'support',
+                                      'filesystem_dynamic_test_helper.py')
+        assert os.path.isfile(dynamic_helper)
+
+        self.cxx.compile_flags += ['-DLIBCXX_FILESYSTEM_DYNAMIC_TEST_HELPER="%s %s"'
+                                   % (sys.executable, dynamic_helper)]
+
+
     def configure_link_flags(self):
         no_default_flags = self.get_lit_bool('no_default_flags', False)
         if not no_default_flags:
@@ -430,23 +480,11 @@ class Configuration(object):
         self.cxx.link_flags += shlex.split(link_flags_str)
 
     def configure_link_flags_cxx_library_path(self):
-        libcxx_library = self.get_lit_conf('libcxx_library')
-        # Configure libc++ library paths.
-        if libcxx_library is not None:
-            # Check that the given value for libcxx_library is valid.
-            if not os.path.isfile(libcxx_library):
-                self.lit_config.fatal(
-                    "libcxx_library='%s' is not a valid file." %
-                    libcxx_library)
-            if self.use_system_cxx_lib:
-                self.lit_config.fatal(
-                    "Conflicting options: 'libcxx_library' cannot be used "
-                    "with 'use_system_cxx_lib=true'")
-            self.cxx.link_flags += ['-Wl,-rpath,' +
-                                    os.path.dirname(libcxx_library)]
-        elif not self.use_system_cxx_lib and self.cxx_library_root:
-            self.cxx.link_flags += ['-L' + self.cxx_library_root,
-                                    '-Wl,-rpath,' + self.cxx_library_root]
+        if not self.use_system_cxx_lib:
+            if self.cxx_library_root:
+                self.cxx.link_flags += ['-L' + self.cxx_library_root]
+            if self.cxx_runtime_root:
+                self.cxx.link_flags += ['-Wl,-rpath,' + self.cxx_runtime_root]
 
     def configure_link_flags_abi_library_path(self):
         # Configure ABI library paths.
@@ -456,11 +494,20 @@ class Configuration(object):
                                     '-Wl,-rpath,' + self.abi_library_root]
 
     def configure_link_flags_cxx_library(self):
-        libcxx_library = self.get_lit_conf('libcxx_library')
-        if libcxx_library:
-            self.cxx.link_flags += [libcxx_library]
-        else:
+        libcxx_experimental = self.get_lit_bool('enable_experimental', default=False)
+        if libcxx_experimental:
+            self.config.available_features.add('c++experimental')
+            self.cxx.link_flags += ['-lc++experimental']
+        libcxx_shared = self.get_lit_bool('enable_shared', default=True)
+        if libcxx_shared:
             self.cxx.link_flags += ['-lc++']
+        else:
+            cxx_library_root = self.get_lit_conf('cxx_library_root')
+            if cxx_library_root:
+                abs_path = os.path.join(cxx_library_root, 'libc++.a')
+                self.cxx.link_flags += [abs_path]
+            else:
+                self.cxx.link_flags += ['-lc++']
 
     def configure_link_flags_abi_library(self):
         cxx_abi = self.get_lit_conf('cxx_abi', 'libcxxabi')
@@ -470,7 +517,16 @@ class Configuration(object):
             self.cxx.link_flags += ['-lsupc++']
         elif cxx_abi == 'libcxxabi':
             if self.target_info.allow_cxxabi_link():
-                self.cxx.link_flags += ['-lc++abi']
+                libcxxabi_shared = self.get_lit_bool('libcxxabi_shared', default=True)
+                if libcxxabi_shared:
+                    self.cxx.link_flags += ['-lc++abi']
+                else:
+                    cxxabi_library_root = self.get_lit_conf('abi_library_path')
+                    if cxxabi_library_root:
+                        abs_path = os.path.join(cxxabi_library_root, 'libc++abi.a')
+                        self.cxx.link_flags += [abs_path]
+                    else:
+                        self.cxx.link_flags += ['-lc++abi']
         elif cxx_abi == 'libcxxrt':
             self.cxx.link_flags += ['-lcxxrt']
         elif cxx_abi == 'none':
@@ -515,8 +571,9 @@ class Configuration(object):
         if enable_warnings:
             self.cxx.compile_flags += [
                 '-D_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER',
-                '-Wall', '-Werror'
+                '-Wall', '-Wextra', '-Werror'
             ]
+            self.cxx.addWarningFlagIfSupported('-Wno-unused-command-line-argument')
             self.cxx.addWarningFlagIfSupported('-Wno-attributes')
             self.cxx.addWarningFlagIfSupported('-Wno-pessimizing-move')
             self.cxx.addWarningFlagIfSupported('-Wno-c++11-extensions')
@@ -525,6 +582,8 @@ class Configuration(object):
             # compiles clean with them.
             self.cxx.addWarningFlagIfSupported('-Wno-unused-local-typedef')
             self.cxx.addWarningFlagIfSupported('-Wno-unused-variable')
+            self.cxx.addWarningFlagIfSupported('-Wno-unused-parameter')
+            self.cxx.addWarningFlagIfSupported('-Wno-sign-compare')
             std = self.get_lit_conf('std', None)
             if std in ['c++98', 'c++03']:
                 # The '#define static_assert' provided by libc++ in C++03 mode
@@ -551,6 +610,9 @@ class Configuration(object):
                 self.cxx.flags += ['-fsanitize=address']
                 if llvm_symbolizer is not None:
                     self.env['ASAN_SYMBOLIZER_PATH'] = llvm_symbolizer
+                # FIXME: Turn ODR violation back on after PR28391 is resolved
+                # https://llvm.org/bugs/show_bug.cgi?id=28391
+                self.env['ASAN_OPTIONS'] = 'detect_odr_violation=0'
                 self.config.available_features.add('asan')
                 self.config.available_features.add('sanitizer-new-delete')
             elif san == 'Memory' or san == 'MemoryWithOrigins':
@@ -563,9 +625,12 @@ class Configuration(object):
                 self.config.available_features.add('msan')
                 self.config.available_features.add('sanitizer-new-delete')
             elif san == 'Undefined':
+                blacklist = os.path.join(self.libcxx_src_root,
+                                         'test/ubsan_blacklist.txt')
                 self.cxx.flags += ['-fsanitize=undefined',
-                                   '-fno-sanitize=vptr,function',
-                                   '-fno-sanitize-recover']
+                                   '-fno-sanitize=vptr,function,float-divide-by-zero',
+                                   '-fno-sanitize-recover=all',
+                                   '-fsanitize-blacklist=' + blacklist]
                 self.cxx.compile_flags += ['-O3']
                 self.env['UBSAN_OPTIONS'] = 'print_stacktrace=1'
                 self.config.available_features.add('ubsan')
diff --git a/test/libcxx/test/format.py b/test/libcxx/test/format.py
index aaa9a1845ae4..b9ec2ba2aa7b 100644
--- a/test/libcxx/test/format.py
+++ b/test/libcxx/test/format.py
@@ -161,12 +161,19 @@ class LibcxxTestFormat(object):
                        'expected-error', 'expected-no-diagnostics']
         use_verify = self.use_verify_for_fail and \
                      any([tag in contents for tag in verify_tags])
-        extra_flags = ['-fsyntax-only']
+        # FIXME(EricWF): GCC 5 does not evaluate static assertions that
+        # are dependant on a template parameter when '-fsyntax-only' is passed.
+        # This is fixed in GCC 6. However for now we only pass "-fsyntax-only"
+        # when using Clang.
+        extra_flags = []
+        if self.cxx.type != 'gcc':
+            extra_flags += ['-fsyntax-only']
         if use_verify:
             extra_flags += ['-Xclang', '-verify',
                             '-Xclang', '-verify-ignore-unexpected=note']
         cmd, out, err, rc = self.cxx.compile(source_path, out=os.devnull,
-                                             flags=extra_flags)
+                                             flags=extra_flags,
+                                             disable_ccache=True)
         expected_rc = 0 if use_verify else 1
         if rc == expected_rc:
             return lit.Test.PASS, ''
diff --git a/test/libcxx/test/target_info.py b/test/libcxx/test/target_info.py
index 7ca08bea193a..a743595a1046 100644
--- a/test/libcxx/test/target_info.py
+++ b/test/libcxx/test/target_info.py
@@ -90,13 +90,10 @@ class DarwinLocalTI(DefaultTargetInfo):
     def configure_env(self, env):
         library_paths = []
         # Configure the library path for libc++
-        libcxx_library = self.full_config.get_lit_conf('libcxx_library')
         if self.full_config.use_system_cxx_lib:
             pass
-        elif libcxx_library:
-            library_paths += [os.path.dirname(libcxx_library)]
-        elif self.full_config.cxx_library_root:
-            library_paths += [self.full_config.cxx_library_root]
+        elif self.full_config.cxx_runtime_root:
+            library_paths += [self.full_config.cxx_runtime_root]
         # Configure the abi library path
         if self.full_config.abi_library_root:
             library_paths += [self.full_config.abi_library_root]
@@ -104,6 +101,15 @@ class DarwinLocalTI(DefaultTargetInfo):
             env['DYLD_LIBRARY_PATH'] = ':'.join(library_paths)
 
     def allow_cxxabi_link(self):
+        # FIXME: PR27405
+        # libc++ *should* export all of the symbols found in libc++abi on OS X.
+        # For this reason LibcxxConfiguration will not link libc++abi in OS X.
+        # However __cxa_throw_bad_new_array_length doesn't get exported into
+        # libc++ yet so we still need to explicitly link libc++abi when testing
+        # libc++abi
+        # See PR22654.
+        if(self.full_config.get_lit_conf('name', '') == 'libc++abi'):
+            return True
         # Don't link libc++abi explicitly on OS X because the symbols
         # should be available in libc++ directly.
         return False
@@ -162,16 +168,22 @@ class LinuxLocalTI(DefaultTargetInfo):
         enable_threads = ('libcpp-has-no-threads' not in
                           self.full_config.config.available_features)
         llvm_unwinder = self.full_config.get_lit_bool('llvm_unwinder', False)
+        shared_libcxx = self.full_config.get_lit_bool('enable_shared', True)
         flags += ['-lm']
         if not llvm_unwinder:
             flags += ['-lgcc_s', '-lgcc']
         if enable_threads:
             flags += ['-lpthread']
+            if not shared_libcxx:
+              flags += ['-lrt']
         flags += ['-lc']
         if llvm_unwinder:
             flags += ['-lunwind', '-ldl']
         else:
             flags += ['-lgcc_s', '-lgcc']
+        use_libatomic = self.full_config.get_lit_bool('use_libatomic', False)
+        if use_libatomic:
+            flags += ['-latomic']
         san = self.full_config.get_lit_conf('use_sanitizer', '').strip()
         if san:
             # The libraries and their order are taken from the
diff --git a/test/libcxx/thread/futures/futures.promise/set_exception.pass.cpp b/test/libcxx/thread/futures/futures.promise/set_exception.pass.cpp
new file mode 100644
index 000000000000..bf567a30243a
--- /dev/null
+++ b/test/libcxx/thread/futures/futures.promise/set_exception.pass.cpp
@@ -0,0 +1,53 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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: libcpp-no-exceptions
+// UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
+
+// <future>
+
+// class promise<R>
+
+// void set_exception(exception_ptr p);
+// Test that a null exception_ptr is diagnosed.
+
+#define _LIBCPP_ASSERT(x, m) ((x) ? ((void)0) : throw 42)
+
+#define _LIBCPP_DEBUG 0
+#include <future>
+#include <exception>
+#include <cstdlib>
+#include <cassert>
+
+
+int main()
+{
+    {
+        typedef int T;
+        std::promise<T> p;
+        try {
+            p.set_exception(std::exception_ptr());
+            assert(false);
+        } catch (int const& value) {
+            assert(value == 42);
+        }
+    }
+    {
+        typedef int& T;
+        std::promise<T> p;
+        try {
+            p.set_exception(std::exception_ptr());
+            assert(false);
+        } catch (int const& value) {
+            assert(value == 42);
+        }
+    }
+}
diff --git a/test/libcxx/thread/futures/futures.promise/set_exception_at_thread_exit.pass.cpp b/test/libcxx/thread/futures/futures.promise/set_exception_at_thread_exit.pass.cpp
new file mode 100644
index 000000000000..1cb61d9af297
--- /dev/null
+++ b/test/libcxx/thread/futures/futures.promise/set_exception_at_thread_exit.pass.cpp
@@ -0,0 +1,53 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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: libcpp-no-exceptions
+// UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
+
+// <future>
+
+// class promise<R>
+
+// void set_exception_on_thread_exit(exception_ptr p);
+// Test that a null exception_ptr is diagnosed.
+
+#define _LIBCPP_ASSERT(x, m) ((x) ? ((void)0) : throw 42)
+
+#define _LIBCPP_DEBUG 0
+#include <future>
+#include <exception>
+#include <cstdlib>
+#include <cassert>
+
+
+int main()
+{
+    {
+        typedef int T;
+        std::promise<T> p;
+        try {
+            p.set_exception_at_thread_exit(std::exception_ptr());
+            assert(false);
+        } catch (int const& value) {
+            assert(value == 42);
+        }
+    }
+    {
+        typedef int& T;
+        std::promise<T> p;
+        try {
+            p.set_exception_at_thread_exit(std::exception_ptr());
+            assert(false);
+        } catch (int const& value) {
+            assert(value == 42);
+        }
+    }
+}
diff --git a/test/std/thread/futures/futures.tas/types.pass.cpp b/test/libcxx/thread/futures/futures.task/types.pass.cpp
index f7c9b223add1..cb0fb803c6ab 100644
--- a/test/std/thread/futures/futures.tas/types.pass.cpp
+++ b/test/libcxx/thread/futures/futures.task/types.pass.cpp
@@ -16,7 +16,9 @@
 //     class packaged_task<R(ArgTypes...)>
 // {
 // public:
-//     typedef R result_type;
+//     typedef R result_type; // extension
+
+// This is a libc++ extension.
 
 #include <future>
 #include <type_traits>
diff --git a/test/std/thread/thread.condition/thread.condition.condvar/native_handle.pass.cpp b/test/libcxx/thread/thread.condition/thread.condition.condvar/native_handle.pass.cpp
index bf28e01a0e86..bf28e01a0e86 100644
--- a/test/std/thread/thread.condition/thread.condition.condvar/native_handle.pass.cpp
+++ b/test/libcxx/thread/thread.condition/thread.condition.condvar/native_handle.pass.cpp
diff --git a/test/std/thread/thread.condition/version.pass.cpp b/test/libcxx/thread/thread.condition/version.pass.cpp
index 12a775e83398..12a775e83398 100644
--- a/test/std/thread/thread.condition/version.pass.cpp
+++ b/test/libcxx/thread/thread.condition/version.pass.cpp
diff --git a/test/libcxx/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_mutex_mangling.pass.cpp b/test/libcxx/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_mutex_mangling.pass.cpp
new file mode 100644
index 000000000000..aae0afbffd37
--- /dev/null
+++ b/test/libcxx/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_mutex_mangling.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: libcpp-has-no-threads
+
+// TODO(EricWF) Investigate why typeid(...).name() returns a different string
+// on GCC 4.9 but not newer GCCs.
+// XFAIL: gcc-4.9
+
+// THIS TESTS C++03 EXTENSIONS.
+
+// <mutex>
+
+// template <class ...Mutex> class lock_guard;
+
+// Test that the the variadic lock guard implementation mangles the same in
+// C++11 and C++03. This is important since the mangling of `lock_guard` depends
+// on it being declared as a variadic template, even in C++03.
+
+#define _LIBCPP_ABI_VARIADIC_LOCK_GUARD
+#include <mutex>
+#include <string>
+#include <typeinfo>
+#include <cassert>
+
+int main() {
+    const std::string expect = "NSt3__110lock_guardIJNS_5mutexEEEE";
+    assert(typeid(std::lock_guard<std::mutex>).name() == expect);
+}
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/native_handle.pass.cpp b/test/libcxx/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/native_handle.pass.cpp
index 12c80f02c340..12c80f02c340 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/native_handle.pass.cpp
+++ b/test/libcxx/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/native_handle.pass.cpp
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/native_handle.pass.cpp b/test/libcxx/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/native_handle.pass.cpp
index 10626bc4072e..10626bc4072e 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/native_handle.pass.cpp
+++ b/test/libcxx/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/native_handle.pass.cpp
diff --git a/test/libcxx/thread/thread.mutex/thread_safety_annotations_not_enabled.pass.cpp b/test/libcxx/thread/thread.mutex/thread_safety_annotations_not_enabled.pass.cpp
new file mode 100644
index 000000000000..d9ac92c270c3
--- /dev/null
+++ b/test/libcxx/thread/thread.mutex/thread_safety_annotations_not_enabled.pass.cpp
@@ -0,0 +1,26 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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: libcpp-has-no-threads
+
+// <mutex>
+
+// This test does not define _LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS so it
+// should compile without any warnings or errors even though this pattern is not
+// understood by the thread safety annotations.
+
+#include <mutex>
+
+int main() {
+  std::mutex m;
+  m.lock();
+  {
+    std::unique_lock<std::mutex> g(m, std::adopt_lock);
+  }
+}
diff --git a/test/libcxx/thread/thread.mutex/thread_safety_lock_guard.pass.cpp b/test/libcxx/thread/thread.mutex/thread_safety_lock_guard.pass.cpp
new file mode 100644
index 000000000000..4e85a039686a
--- /dev/null
+++ b/test/libcxx/thread/thread.mutex/thread_safety_lock_guard.pass.cpp
@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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: libcpp-has-no-threads
+// REQUIRES: thread-safety
+
+// <mutex>
+
+#define _LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS
+
+#include <mutex>
+
+std::mutex m;
+int foo __attribute__((guarded_by(m)));
+
+int main() {
+  std::lock_guard<std::mutex> lock(m);
+  foo++;
+}
diff --git a/test/libcxx/thread/thread.mutex/thread_safety_lock_unlock.pass.cpp b/test/libcxx/thread/thread.mutex/thread_safety_lock_unlock.pass.cpp
new file mode 100644
index 000000000000..40b97c396ad6
--- /dev/null
+++ b/test/libcxx/thread/thread.mutex/thread_safety_lock_unlock.pass.cpp
@@ -0,0 +1,26 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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: libcpp-has-no-threads
+// REQUIRES: thread-safety
+
+// <mutex>
+
+#define _LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS
+
+#include <mutex>
+
+std::mutex m;
+int foo __attribute__((guarded_by(m)));
+
+int main() {
+  m.lock();
+  foo++;
+  m.unlock();
+}
diff --git a/test/libcxx/thread/thread.mutex/thread_safety_missing_unlock.fail.cpp b/test/libcxx/thread/thread.mutex/thread_safety_missing_unlock.fail.cpp
new file mode 100644
index 000000000000..c1425c960c00
--- /dev/null
+++ b/test/libcxx/thread/thread.mutex/thread_safety_missing_unlock.fail.cpp
@@ -0,0 +1,23 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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: libcpp-has-no-threads
+// REQUIRES: thread-safety
+
+// <mutex>
+
+#define _LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS
+
+#include <mutex>
+
+std::mutex m;
+
+int main() {
+  m.lock();
+} // expected-error {{mutex 'm' is still held at the end of function}}
diff --git a/test/libcxx/thread/thread.mutex/thread_safety_requires_capability.pass.cpp b/test/libcxx/thread/thread.mutex/thread_safety_requires_capability.pass.cpp
new file mode 100644
index 000000000000..e03f5eabffcf
--- /dev/null
+++ b/test/libcxx/thread/thread.mutex/thread_safety_requires_capability.pass.cpp
@@ -0,0 +1,30 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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: libcpp-has-no-threads
+// REQUIRES: thread-safety
+
+// <mutex>
+
+#define _LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS
+
+#include <mutex>
+
+std::mutex m;
+int foo __attribute__((guarded_by(m)));
+
+void increment() __attribute__((requires_capability(m))) {
+  foo++;
+}
+
+int main() {
+  m.lock();
+  increment();
+  m.unlock();
+}
diff --git a/test/std/thread/thread.mutex/version.pass.cpp b/test/libcxx/thread/thread.mutex/version.pass.cpp
index 81b52c79204b..81b52c79204b 100644
--- a/test/std/thread/thread.mutex/version.pass.cpp
+++ b/test/libcxx/thread/thread.mutex/version.pass.cpp
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/native_handle.pass.cpp b/test/libcxx/thread/thread.threads/thread.thread.class/thread.thread.member/native_handle.pass.cpp
index c8807a965c44..c8807a965c44 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/native_handle.pass.cpp
+++ b/test/libcxx/thread/thread.threads/thread.thread.class/thread.thread.member/native_handle.pass.cpp
diff --git a/test/std/thread/thread.threads/thread.thread.class/types.pass.cpp b/test/libcxx/thread/thread.threads/thread.thread.class/types.pass.cpp
index a5bf77031cca..a5bf77031cca 100644
--- a/test/std/thread/thread.threads/thread.thread.class/types.pass.cpp
+++ b/test/libcxx/thread/thread.threads/thread.thread.class/types.pass.cpp
diff --git a/test/std/thread/thread.threads/version.pass.cpp b/test/libcxx/thread/thread.threads/version.pass.cpp
index d16b0eb06842..d16b0eb06842 100644
--- a/test/std/thread/thread.threads/version.pass.cpp
+++ b/test/libcxx/thread/thread.threads/version.pass.cpp
diff --git a/test/std/utilities/function.objects/func.require/bullet_1_and_2.pass.cpp b/test/libcxx/utilities/function.objects/func.require/bullet_1_2_3.pass.cpp
index e579f207a33f..509c751b455d 100644
--- a/test/std/utilities/function.objects/func.require/bullet_1_and_2.pass.cpp
+++ b/test/libcxx/utilities/function.objects/func.require/bullet_1_2_3.pass.cpp
@@ -14,12 +14,14 @@
 //------------------------------------------------------------------------------
 // TESTING INVOKE(f, t1, t2, ..., tN)
 //   - Bullet 1 -- (t1.*f)(t2, ..., tN)
-//   - Bullet 2 -- ((*t1).*f)(t2, ..., tN)
+//   - Bullet 2 -- (t1.get().*f)(t2, ..., tN) // t1 is a reference_wrapper
+//   - Bullet 3 -- ((*t1).*f)(t2, ..., tN)
 //
 // Overview:
-//    Bullets 1 and 2 handle the case where 'f' is a pointer to member function.
+//    Bullets 1, 2 and 3 handle the case where 'f' is a pointer to member function.
 //    Bullet 1 only handles the cases where t1 is an object of type T or a
-//    type derived from 'T'. Bullet 2 handles all other cases.
+//    type derived from 'T'. Bullet 2 handles the case where 't1' is a reference
+//    wrapper and bullet 3 handles all other cases.
 //
 // Concerns:
 //   1) cv-qualified member function signatures are accepted.
@@ -31,6 +33,7 @@
 //      as the call object.
 //   7) Pointers to T or a type derived from T can be used as the call object.
 //   8) Reference return types are properly deduced.
+//   9) reference_wrappers are properly handled and unwrapped.
 //
 //
 // Plan:
@@ -123,6 +126,7 @@ private:
 #endif // TEST_STD_VER >= 11
 
 
+
 //==============================================================================
 // TestCase - A test case for a single member function.
 //   ClassType - The type of the class being tested.
@@ -151,6 +155,8 @@ private:
         D* der_ptr = &der;
         DerefToType<T>   dref;
         DerefPropType<T> dref2;
+        std::reference_wrapper<T> rref(obj);
+        std::reference_wrapper<D> drref(der);
 
          // (Plan-3) Dispatch based on the CV tags.
         CV tag;
@@ -158,9 +164,13 @@ private:
         runTestDispatch(tag,  obj);
         runTestDispatch(tag,  der);
         runTestDispatch(tag, dref2);
-        runTestDispatchIf(NotRValue, tag,  dref);
-        runTestDispatchIf(NotRValue, tag,  obj_ptr);
+        runTestDispatchIf(NotRValue, tag, dref);
+        runTestDispatchIf(NotRValue, tag, obj_ptr);
         runTestDispatchIf(NotRValue, tag, der_ptr);
+#if TEST_STD_VER >= 11
+        runTestDispatchIf(NotRValue, tag, rref);
+        runTestDispatchIf(NotRValue, tag, drref);
+#endif
     }
 
     template <class QT, class Tp>
@@ -179,27 +189,43 @@ private:
 
     template <class Tp>
     void runTestDispatch(Q_Const, Tp& v) {
-        Tp const& cv = v;
         runTest(v);
-        runTest(cv);
+        runTest(makeConst(v));
     }
 
     template <class Tp>
     void runTestDispatch(Q_Volatile, Tp& v) {
-        Tp volatile& vv = v;
         runTest(v);
-        runTest(vv);
+        runTest(makeVolatile(v));
+
     }
 
     template <class Tp>
     void runTestDispatch(Q_CV, Tp& v) {
-        Tp const& cv = v;
-        Tp volatile& vv = v;
-        Tp const volatile& cvv = v;
         runTest(v);
-        runTest(cv);
-        runTest(vv);
-        runTest(cvv);
+        runTest(makeConst(v));
+        runTest(makeVolatile(v));
+        runTest(makeCV(v));
+    }
+
+    template <class T>
+    void runTest(const std::reference_wrapper<T>& obj) {
+        typedef Caster<Q_None, RValue> SCast;
+        typedef Caster<Q_None, ArgRValue> ACast;
+        typedef CallSig (ClassType::*MemPtr);
+        // Delegate test to logic in invoke_helpers.h
+        BasicTest<MethodID<MemPtr>, Arity, SCast, ACast> b;
+        b.runTest( (MemPtr)&ClassType::f, obj);
+    }
+
+    template <class T>
+    void runTest(T* obj) {
+        typedef Caster<Q_None, RValue> SCast;
+        typedef Caster<Q_None, ArgRValue> ACast;
+        typedef CallSig (ClassType::*MemPtr);
+        // Delegate test to logic in invoke_helpers.h
+        BasicTest<MethodID<MemPtr>, Arity, SCast, ACast> b;
+        b.runTest( (MemPtr)&ClassType::f, obj);
     }
 
     template <class Obj>
@@ -221,6 +247,30 @@ template <class Sig, int Arity, class CV, bool RValue = false>
 struct TestCase11 : public TestCaseImp<MemFun11, Sig, Arity, CV, RValue, true> {};
 #endif
 
+template <class Tp>
+struct DerivedFromRefWrap : public std::reference_wrapper<Tp> {
+  DerivedFromRefWrap(Tp& tp) : std::reference_wrapper<Tp>(tp) {}
+};
+
+#if TEST_STD_VER >= 11
+void test_derived_from_ref_wrap() {
+    int x = 42;
+    std::reference_wrapper<int> r(x);
+    std::reference_wrapper<std::reference_wrapper<int>> r2(r);
+    DerivedFromRefWrap<int> d(x);
+    auto get_fn = &std::reference_wrapper<int>::get;
+    auto& ret = std::__invoke(get_fn, r);
+    auto& cret = std::__invoke_constexpr(get_fn, r);
+    assert(&ret == &x);
+    assert(&cret == &x);
+    auto& ret2 = std::__invoke(get_fn, d);
+    auto& cret2 = std::__invoke_constexpr(get_fn, d);
+    assert(&ret2 == &x);
+    auto& ret3 = std::__invoke(get_fn, r2);
+    assert(&ret3 == &x);
+}
+#endif
+
 int main() {
     typedef void*& R;
     typedef ArgType A;
@@ -314,5 +364,7 @@ int main() {
     TestCase11<R(A&&, A&&, A&&, ...)  const &&,           3, Q_Const, /* RValue */ true>::run();
     TestCase11<R(A&&, A&&, A&&, ...)  volatile &&,        3, Q_Volatile, /* RValue */ true>::run();
     TestCase11<R(A&&, A&&, A&&, ...)  const volatile &&,  3, Q_CV, /* RValue */ true>::run();
+
+    test_derived_from_ref_wrap();
 #endif
 }
\ No newline at end of file
diff --git a/test/std/utilities/function.objects/func.require/bullet_3_and_4.pass.cpp b/test/libcxx/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp
index b6fe190bd2a7..803c501f8c9e 100644
--- a/test/std/utilities/function.objects/func.require/bullet_3_and_4.pass.cpp
+++ b/test/libcxx/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp
@@ -13,13 +13,15 @@
 
 //------------------------------------------------------------------------------
 // TESTING INVOKE(f, t1, t2, ..., tN)
-//   - Bullet 3 -- t1.*f
-//   - Bullet 4 -- (*t1).*f
+//   - Bullet 4 -- t1.*f
+//   - Bullet 5 -- t1.get().*f // t1 is a reference wrapper.
+//   - Bullet 6 -- (*t1).*f
 //
 // Overview:
-//    Bullets 3 and 4 handle the case where 'f' is a pointer to member object.
-//    Bullet 3 only handles the cases where t1 is an object of type T or a
-//    type derived from 'T'. Bullet 4 handles all other cases.
+//    Bullets 4, 5 and 6 handle the case where 'f' is a pointer to member object.
+//    Bullet 4 only handles the cases where t1 is an object of type T or a
+//    type derived from 'T'. Bullet 5 handles cases where 't1' is a reference_wrapper
+//     and bullet 6 handles all other cases.
 //
 // Concerns:
 //   1) The return type is always an lvalue reference.
@@ -30,6 +32,7 @@
 //   6) All types that dereference to T or a type derived from T can be used
 //      as the call object.
 //   7) Pointers to T or a type derived from T can be used as the call object.
+//   8) reference_wrapper's are properly unwrapped before invoking the function.
 
 #include <functional>
 #include <type_traits>
@@ -66,6 +69,8 @@ private:
         Derived* der_ptr = &der;
         DerefToType<TestType>   dref;
         DerefPropType<TestType> dref2;
+        std::reference_wrapper<TestType> rref(obj);
+        std::reference_wrapper<Derived> drref(der);
 
         {
             typedef ObjectType (TestType::*MemPtr);
@@ -74,9 +79,13 @@ private:
             runTestDispatch<E>(M, obj, &obj.object);
             runTestDispatch<E>(M, der, &der.object);
             runTestDispatch<E>(M, dref2, &dref2.object.object);
-            runTestPointerDispatch<E>(M, obj_ptr, &obj_ptr->object);
-            runTestPointerDispatch<E>(M, der_ptr, &der_ptr->object);
-            runTestPointerDispatch<E>(M, dref, &dref.object.object);
+            runTestPropCVDispatch<E>(M, obj_ptr, &obj_ptr->object);
+            runTestPropCVDispatch<E>(M, der_ptr, &der_ptr->object);
+#if TEST_STD_VER >= 11
+            runTestPropCVDispatch<E>(M, rref, &(rref.get().object));
+            runTestPropCVDispatch<E>(M, drref, &(drref.get().object));
+#endif
+            runTestNoPropDispatch<E>(M, dref, &dref.object.object);
         }
         {
             typedef ObjectType const (TestType::*CMemPtr);
@@ -85,9 +94,13 @@ private:
             runTestDispatch<E>(M, obj, &obj.object);
             runTestDispatch<E>(M, der, &der.object);
             runTestDispatch<E>(M, dref2, &dref2.object.object);
-            runTestPointerDispatch<E>(M, obj_ptr, &obj_ptr->object);
-            runTestPointerDispatch<E>(M, der_ptr, &der_ptr->object);
-            runTestPointerDispatch<E>(M, dref, &dref.object.object);
+            runTestPropCVDispatch<E>(M, obj_ptr, &obj_ptr->object);
+            runTestPropCVDispatch<E>(M, der_ptr, &der_ptr->object);
+#if TEST_STD_VER >= 11
+            runTestPropCVDispatch<E>(M, rref, &(rref.get().object));
+            runTestPropCVDispatch<E>(M, drref, &(drref.get().object));
+#endif
+            runTestNoPropDispatch<E>(M, dref,    &dref.object.object);
         }
         {
             typedef ObjectType volatile (TestType::*VMemPtr);
@@ -96,9 +109,13 @@ private:
             runTestDispatch<E>(M, obj,  &obj.object);
             runTestDispatch<E>(M, der,  &der.object);
             runTestDispatch<E>(M, dref2, &dref2.object.object);
-            runTestPointerDispatch<E>(M, obj_ptr, &obj_ptr->object);
-            runTestPointerDispatch<E>(M, der_ptr, &der_ptr->object);
-            runTestPointerDispatch<E>(M, dref,    &dref.object.object);
+            runTestPropCVDispatch<E>(M, obj_ptr, &obj_ptr->object);
+            runTestPropCVDispatch<E>(M, der_ptr, &der_ptr->object);
+#if TEST_STD_VER >= 11
+            runTestPropCVDispatch<E>(M, rref, &(rref.get().object));
+            runTestPropCVDispatch<E>(M, drref, &(drref.get().object));
+#endif
+            runTestNoPropDispatch<E>(M, dref,    &dref.object.object);
         }
         {
             typedef ObjectType const volatile (TestType::*CVMemPtr);
@@ -107,9 +124,13 @@ private:
             runTestDispatch<E>(M, obj,   &obj.object);
             runTestDispatch<E>(M, der,   &der.object);
             runTestDispatch<E>(M, dref2, &dref2.object.object);
-            runTestPointerDispatch<E>(M, obj_ptr, &obj_ptr->object);
-            runTestPointerDispatch<E>(M, der_ptr, &der_ptr->object);
-            runTestPointerDispatch<E>(M, dref,    &dref.object.object);
+            runTestPropCVDispatch<E>(M, obj_ptr, &obj_ptr->object);
+            runTestPropCVDispatch<E>(M, der_ptr, &der_ptr->object);
+#if TEST_STD_VER >= 11
+            runTestPropCVDispatch<E>(M, rref, &(rref.get().object));
+            runTestPropCVDispatch<E>(M, drref, &(drref.get().object));
+#endif
+            runTestNoPropDispatch<E>(M, dref,    &dref.object.object);
         }
     }
 
@@ -128,7 +149,15 @@ private:
     }
 
     template <class Expect, class Fn, class T>
-    void runTestPointerDispatch(Fn M, T& obj, ObjectType* expect) {
+    void runTestPropCVDispatch(Fn M, T& obj, ObjectType* expect) {
+        runTest<Expect &>              (M, obj,                     expect);
+        runTest<Expect const&>         (M, makeConst(obj),          expect);
+        runTest<Expect volatile&>      (M, makeVolatile(obj),       expect);
+        runTest<Expect const volatile&>(M, makeCV(obj),             expect);
+    }
+
+    template <class Expect, class Fn, class T>
+    void runTestNoPropDispatch(Fn M, T& obj, ObjectType* expect) {
         runTest<Expect&>(M, C_<T &>(obj),               expect);
         runTest<Expect&>(M, C_<T const&>(obj),          expect);
         runTest<Expect&>(M, C_<T volatile&>(obj),       expect);
@@ -142,19 +171,42 @@ private:
     }
 
     template <class Expect, class Fn, class T>
+    void runTest(Fn M, const T& obj, ObjectType* expect) {
+         static_assert((std::is_same<
+            decltype(std::__invoke(M, obj)), Expect
+          >::value), "");
+        Expect e = std::__invoke(M, obj);
+        assert(&e == expect);
+    }
+
+    template <class Expect, class Fn, class T>
 #if TEST_STD_VER >= 11
     void runTest(Fn M, T&& obj, ObjectType* expect) {
 #else
     void runTest(Fn M, T& obj, ObjectType* expect ) {
 #endif
-        static_assert((std::is_same<
-            decltype(std::__invoke(M, std::forward<T>(obj))), Expect
-          >::value), "");
-        Expect e = std::__invoke(M, std::forward<T>(obj));
-        assert(&e == expect);
+        {
+            static_assert((std::is_same<
+                decltype(std::__invoke(M, std::forward<T>(obj))), Expect
+              >::value), "");
+            Expect e = std::__invoke(M, std::forward<T>(obj));
+            assert(&e == expect);
+        }
+#if TEST_STD_VER >= 11
+        {
+            static_assert((std::is_same<
+                decltype(std::__invoke_constexpr(M, std::forward<T>(obj))), Expect
+              >::value), "");
+            Expect e = std::__invoke_constexpr(M, std::forward<T>(obj));
+            assert(&e == expect);
+        }
+#endif
     }
 };
 
+
+
+
 int main() {
     TestCase<ArgType>::run();
     TestCase<ArgType const>::run();
diff --git a/test/std/utilities/function.objects/func.require/bullet_5.pass.cpp b/test/libcxx/utilities/function.objects/func.require/bullet_7.pass.cpp
index 3f3c96a9b9bd..0d14a350c897 100644
--- a/test/std/utilities/function.objects/func.require/bullet_5.pass.cpp
+++ b/test/libcxx/utilities/function.objects/func.require/bullet_7.pass.cpp
@@ -13,10 +13,10 @@
 
 //------------------------------------------------------------------------------
 // TESTING INVOKE(f, t1, t2, ..., tN)
-//   - Bullet 5 -- f(t2, ..., tN)
+//   - Bullet 7 -- f(t2, ..., tN)
 //
 // Overview:
-//    Bullet 5 handles the cases where the first argument is not a member
+//    Bullet 7 handles the cases where the first argument is not a member
 //   function.
 //
 // Concerns:
diff --git a/test/std/utilities/function.objects/func.require/invoke.pass.cpp b/test/libcxx/utilities/function.objects/func.require/invoke.pass.cpp
index 25681630a80c..1d4251354dc5 100644
--- a/test/std/utilities/function.objects/func.require/invoke.pass.cpp
+++ b/test/libcxx/utilities/function.objects/func.require/invoke.pass.cpp
@@ -9,12 +9,10 @@
 
 // [func.require]
 
-// INVOKE
-#if __cplusplus < 201103L
-int main () {}      // no __invoke in C++03
-#else
-
 #include <type_traits>
+#include <functional>
+
+#include "test_macros.h"
 
 template <typename T, int N>
 struct Array
@@ -26,10 +24,9 @@ struct Type
 {
     Array<char, 1>::type& f1();
     Array<char, 2>::type& f2() const;
-    
+#if TEST_STD_VER >= 11
     Array<char, 1>::type& g1()        &;
     Array<char, 2>::type& g2() const  &;
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     Array<char, 3>::type& g3()       &&;
     Array<char, 4>::type& g4() const &&;
 #endif
@@ -39,12 +36,10 @@ int main()
 {
     static_assert(sizeof(std::__invoke(&Type::f1, std::declval<Type        >())) == 1, "");
     static_assert(sizeof(std::__invoke(&Type::f2, std::declval<Type const  >())) == 2, "");
-    
+#if TEST_STD_VER >= 11
     static_assert(sizeof(std::__invoke(&Type::g1, std::declval<Type       &>())) == 1, "");
     static_assert(sizeof(std::__invoke(&Type::g2, std::declval<Type const &>())) == 2, "");
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     static_assert(sizeof(std::__invoke(&Type::g3, std::declval<Type      &&>())) == 3, "");
     static_assert(sizeof(std::__invoke(&Type::g4, std::declval<Type const&&>())) == 4, "");
 #endif
 }
-#endif
diff --git a/test/std/utilities/function.objects/func.require/invoke_helpers.h b/test/libcxx/utilities/function.objects/func.require/invoke_helpers.h
index a85b39f37175..7e7a5fd24a62 100644
--- a/test/std/utilities/function.objects/func.require/invoke_helpers.h
+++ b/test/libcxx/utilities/function.objects/func.require/invoke_helpers.h
@@ -79,6 +79,40 @@ typedef Caster<Q_Const,    true> MoveConstCaster;
 typedef Caster<Q_Volatile, true> MoveVolatileCaster;
 typedef Caster<Q_CV,       true> MoveCVCaster;
 
+
+template <class Tp>
+Tp const& makeConst(Tp& ref) { return ref; }
+
+template <class Tp>
+Tp const* makeConst(Tp* ptr) { return ptr; }
+
+template <class Tp>
+std::reference_wrapper<const Tp> makeConst(std::reference_wrapper<Tp>& ref) {
+    return std::reference_wrapper<const Tp>(ref.get());
+}
+
+template <class Tp>
+Tp volatile& makeVolatile(Tp& ref) { return ref; }
+
+template <class Tp>
+Tp volatile* makeVolatile(Tp* ptr) { return ptr; }
+
+template <class Tp>
+std::reference_wrapper<volatile Tp> makeVolatile(std::reference_wrapper<Tp>& ref) {
+    return std::reference_wrapper<volatile Tp>(ref.get());
+}
+
+template <class Tp>
+Tp const volatile& makeCV(Tp& ref) { return ref; }
+
+template <class Tp>
+Tp const volatile* makeCV(Tp* ptr) { return ptr; }
+
+template <class Tp>
+std::reference_wrapper<const volatile Tp> makeCV(std::reference_wrapper<Tp>& ref) {
+    return std::reference_wrapper<const volatile Tp>(ref.get());
+}
+
 // A shorter name for 'static_cast'
 template <class QualType, class Tp>
 QualType C_(Tp& v) { return static_cast<QualType>(v); };
@@ -237,89 +271,185 @@ private:
     ArgType a0, a1, a2;
 
     //==========================================================================
-    //                       BULLET 1 AND 2 TEST METHODS
+    //                       BULLET 1, 2 AND 3 TEST METHODS
     //==========================================================================
     template <class MethodPtr, class ObjectT>
     void runTestImp(Int<0>, MethodPtr ptr, ObjectT& object) {
-        static_assert((std::is_same<
-            decltype(std::__invoke(ptr, object_cast(object)))
-          , CallRet>::value), "");
-        assert(ID::unchecked_call == false);
-        CallRet ret = std::__invoke(ptr, object_cast(object));
-        assert(ID::checkCalled(ret));
+        {
+            static_assert((std::is_same<
+                decltype(std::__invoke(ptr, object_cast(object)))
+              , CallRet>::value), "");
+            assert(ID::unchecked_call == false);
+            CallRet ret = std::__invoke(ptr, object_cast(object));
+            assert(ID::checkCalled(ret));
+        }
+#if TEST_STD_VER >= 11
+        {
+            static_assert((std::is_same<
+                decltype(std::__invoke_constexpr(ptr, object_cast(object)))
+              , CallRet>::value), "");
+            assert(ID::unchecked_call == false);
+            CallRet ret = std::__invoke_constexpr(ptr, object_cast(object));
+            assert(ID::checkCalled(ret));
+        }
+#endif
     }
 
     template <class MethodPtr, class ObjectT>
     void runTestImp(Int<1>, MethodPtr ptr, ObjectT& object) {
-        static_assert((std::is_same<
-            decltype(std::__invoke(ptr, object_cast(object), arg_cast(a0)))
-          , CallRet>::value), "");
-        assert(ID::unchecked_call == false);
-        CallRet ret = std::__invoke(ptr, object_cast(object), arg_cast(a0));
-        assert(ID::checkCalled(ret));
+        {
+            static_assert((std::is_same<
+                decltype(std::__invoke(ptr, object_cast(object), arg_cast(a0)))
+              , CallRet>::value), "");
+            assert(ID::unchecked_call == false);
+            CallRet ret = std::__invoke(ptr, object_cast(object), arg_cast(a0));
+            assert(ID::checkCalled(ret));
+        }
+#if TEST_STD_VER >= 11
+        {
+            static_assert((std::is_same<
+                decltype(std::__invoke_constexpr(ptr, object_cast(object), arg_cast(a0)))
+              , CallRet>::value), "");
+            assert(ID::unchecked_call == false);
+            CallRet ret = std::__invoke_constexpr(ptr, object_cast(object), arg_cast(a0));
+            assert(ID::checkCalled(ret));
+        }
+#endif
     }
 
     template <class MethodPtr, class ObjectT>
     void runTestImp(Int<2>, MethodPtr ptr, ObjectT& object) {
-        static_assert((std::is_same<
-            decltype(std::__invoke(ptr, object_cast(object), arg_cast(a0), arg_cast(a1)))
-          , CallRet>::value), "");
-        assert(ID::unchecked_call == false);
-        CallRet ret = std::__invoke(ptr, object_cast(object), arg_cast(a0), arg_cast(a1));
-        assert(ID::checkCalled(ret));
+        {
+            static_assert((std::is_same<
+                decltype(std::__invoke(ptr, object_cast(object), arg_cast(a0), arg_cast(a1)))
+              , CallRet>::value), "");
+            assert(ID::unchecked_call == false);
+            CallRet ret = std::__invoke(ptr, object_cast(object), arg_cast(a0), arg_cast(a1));
+            assert(ID::checkCalled(ret));
+        }
+#if TEST_STD_VER >= 11
+        {
+            static_assert((std::is_same<
+                decltype(std::__invoke_constexpr(ptr, object_cast(object), arg_cast(a0), arg_cast(a1)))
+              , CallRet>::value), "");
+            assert(ID::unchecked_call == false);
+            CallRet ret = std::__invoke_constexpr(ptr, object_cast(object), arg_cast(a0), arg_cast(a1));
+            assert(ID::checkCalled(ret));
+        }
+#endif
     }
 
     template <class MethodPtr, class ObjectT>
     void runTestImp(Int<3>, MethodPtr ptr, ObjectT& object) {
-        static_assert((std::is_same<
-            decltype(std::__invoke(ptr, object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2)))
-          , CallRet>::value), "");
-        assert(ID::unchecked_call == false);
-        CallRet ret = std::__invoke(ptr, object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2));
-        assert(ID::checkCalled(ret));
+        {
+            static_assert((std::is_same<
+                decltype(std::__invoke(ptr, object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2)))
+              , CallRet>::value), "");
+            assert(ID::unchecked_call == false);
+            CallRet ret = std::__invoke(ptr, object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2));
+            assert(ID::checkCalled(ret));
+        }
+#if TEST_STD_VER >= 11
+        {
+            static_assert((std::is_same<
+                decltype(std::__invoke_constexpr(ptr, object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2)))
+              , CallRet>::value), "");
+            assert(ID::unchecked_call == false);
+            CallRet ret = std::__invoke_constexpr(ptr, object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2));
+            assert(ID::checkCalled(ret));
+        }
+#endif
     }
 
     //==========================================================================
-    //                       BULLET 5 TEST METHODS
+    //                       BULLET 7 TEST METHODS
     //==========================================================================
     template <class ObjectT>
     void runTestImp(Int<0>, ObjectT& object) {
-        static_assert((std::is_same<
-            decltype(std::__invoke(object_cast(object)))
-          , CallRet>::value), "");
-        assert(ID::unchecked_call == false);
-        CallRet ret = std::__invoke(object_cast(object));
-        assert(ID::checkCalled(ret));
+        {
+            static_assert((std::is_same<
+                decltype(std::__invoke(object_cast(object)))
+              , CallRet>::value), "");
+            assert(ID::unchecked_call == false);
+            CallRet ret = std::__invoke(object_cast(object));
+            assert(ID::checkCalled(ret));
+        }
+#if TEST_STD_VER >= 11
+        {
+            static_assert((std::is_same<
+                decltype(std::__invoke_constexpr(object_cast(object)))
+              , CallRet>::value), "");
+            assert(ID::unchecked_call == false);
+            CallRet ret = std::__invoke_constexpr(object_cast(object));
+            assert(ID::checkCalled(ret));
+        }
+#endif
     }
 
     template <class ObjectT>
     void runTestImp(Int<1>, ObjectT& object) {
-        static_assert((std::is_same<
-            decltype(std::__invoke(object_cast(object), arg_cast(a0)))
-          , CallRet>::value), "");
-        assert(ID::unchecked_call == false);
-        CallRet ret = std::__invoke(object_cast(object), arg_cast(a0));
-        assert(ID::checkCalled(ret));
+        {
+            static_assert((std::is_same<
+                decltype(std::__invoke(object_cast(object), arg_cast(a0)))
+              , CallRet>::value), "");
+            assert(ID::unchecked_call == false);
+            CallRet ret = std::__invoke(object_cast(object), arg_cast(a0));
+            assert(ID::checkCalled(ret));
+        }
+#if TEST_STD_VER >= 11
+        {
+            static_assert((std::is_same<
+                decltype(std::__invoke_constexpr(object_cast(object), arg_cast(a0)))
+              , CallRet>::value), "");
+            assert(ID::unchecked_call == false);
+            CallRet ret = std::__invoke_constexpr(object_cast(object), arg_cast(a0));
+            assert(ID::checkCalled(ret));
+        }
+#endif
     }
 
     template <class ObjectT>
     void runTestImp(Int<2>, ObjectT& object) {
-        static_assert((std::is_same<
-            decltype(std::__invoke(object_cast(object), arg_cast(a0), arg_cast(a1)))
-          , CallRet>::value), "");
-        assert(ID::unchecked_call == false);
-        CallRet ret = std::__invoke(object_cast(object), arg_cast(a0), arg_cast(a1));
-        assert(ID::checkCalled(ret));
+        {
+            static_assert((std::is_same<
+                decltype(std::__invoke(object_cast(object), arg_cast(a0), arg_cast(a1)))
+              , CallRet>::value), "");
+            assert(ID::unchecked_call == false);
+            CallRet ret = std::__invoke(object_cast(object), arg_cast(a0), arg_cast(a1));
+            assert(ID::checkCalled(ret));
+        }
+#if TEST_STD_VER >= 11
+        {
+            static_assert((std::is_same<
+                decltype(std::__invoke_constexpr(object_cast(object), arg_cast(a0), arg_cast(a1)))
+              , CallRet>::value), "");
+            assert(ID::unchecked_call == false);
+            CallRet ret = std::__invoke_constexpr(object_cast(object), arg_cast(a0), arg_cast(a1));
+            assert(ID::checkCalled(ret));
+        }
+#endif
     }
 
     template <class ObjectT>
     void runTestImp(Int<3>, ObjectT& object) {
-        static_assert((std::is_same<
-            decltype(std::__invoke(object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2)))
-          , CallRet>::value), "");
-        assert(ID::unchecked_call == false);
-        CallRet ret = std::__invoke(object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2));
-        assert(ID::checkCalled(ret));
+        {
+            static_assert((std::is_same<
+                decltype(std::__invoke(object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2)))
+              , CallRet>::value), "");
+            assert(ID::unchecked_call == false);
+            CallRet ret = std::__invoke(object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2));
+            assert(ID::checkCalled(ret));
+        }
+#if TEST_STD_VER >= 11
+        {
+            static_assert((std::is_same<
+                decltype(std::__invoke_constexpr(object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2)))
+              , CallRet>::value), "");
+            assert(ID::unchecked_call == false);
+            CallRet ret = std::__invoke_constexpr(object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2));
+            assert(ID::checkCalled(ret));
+        }
+#endif
     }
 };
 
diff --git a/test/std/utilities/function.objects/version.pass.cpp b/test/libcxx/utilities/function.objects/version.pass.cpp
index 99d731a74543..99d731a74543 100644
--- a/test/std/utilities/function.objects/version.pass.cpp
+++ b/test/libcxx/utilities/function.objects/version.pass.cpp
diff --git a/test/std/utilities/memory/version.pass.cpp b/test/libcxx/utilities/memory/version.pass.cpp
index 790c08a3bd2d..790c08a3bd2d 100644
--- a/test/std/utilities/memory/version.pass.cpp
+++ b/test/libcxx/utilities/memory/version.pass.cpp
diff --git a/test/libcxx/utilities/meta/is_referenceable.pass.cpp b/test/libcxx/utilities/meta/is_referenceable.pass.cpp
new file mode 100644
index 000000000000..42b1f2dc3014
--- /dev/null
+++ b/test/libcxx/utilities/meta/is_referenceable.pass.cpp
@@ -0,0 +1,193 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+//
+
+// __is_referenceable<Tp>
+//
+// [defns.referenceable] defines "a referenceable type" as:
+// An object type, a function type that does not have cv-qualifiers
+//    or a ref-qualifier, or a reference type.
+//
+
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct Foo {};
+
+static_assert((!std::__is_referenceable<void>::value), "");
+static_assert(( std::__is_referenceable<int>::value), "");
+static_assert(( std::__is_referenceable<int[3]>::value), "");
+static_assert(( std::__is_referenceable<int[]>::value), "");
+static_assert(( std::__is_referenceable<int &>::value), "");
+static_assert(( std::__is_referenceable<const int &>::value), "");
+static_assert(( std::__is_referenceable<int *>::value), "");
+static_assert(( std::__is_referenceable<const int *>::value), "");
+static_assert(( std::__is_referenceable<Foo>::value), "");
+static_assert(( std::__is_referenceable<const Foo>::value), "");
+static_assert(( std::__is_referenceable<Foo &>::value), "");
+static_assert(( std::__is_referenceable<const Foo &>::value), "");
+#if TEST_STD_VER >= 11
+static_assert(( std::__is_referenceable<Foo &&>::value), "");
+static_assert(( std::__is_referenceable<const Foo &&>::value), "");
+#endif
+
+static_assert(( std::__is_referenceable<int   __attribute__((__vector_size__( 8)))>::value), "");
+static_assert(( std::__is_referenceable<const int   __attribute__((__vector_size__( 8)))>::value), "");
+static_assert(( std::__is_referenceable<float __attribute__((__vector_size__(16)))>::value), "");
+static_assert(( std::__is_referenceable<const float __attribute__((__vector_size__(16)))>::value), "");
+
+// Functions without cv-qualifiers are referenceable
+static_assert(( std::__is_referenceable<void ()>::value), "");
+#if TEST_STD_VER >= 11
+static_assert((!std::__is_referenceable<void () const>::value), "");
+static_assert((!std::__is_referenceable<void () &>::value), "");
+static_assert((!std::__is_referenceable<void () const &>::value), "");
+static_assert((!std::__is_referenceable<void () &&>::value), "");
+static_assert((!std::__is_referenceable<void () const &&>::value), "");
+#endif
+
+static_assert(( std::__is_referenceable<void (int)>::value), "");
+#if TEST_STD_VER >= 11
+static_assert((!std::__is_referenceable<void (int) const>::value), "");
+static_assert((!std::__is_referenceable<void (int) &>::value), "");
+static_assert((!std::__is_referenceable<void (int) const &>::value), "");
+static_assert((!std::__is_referenceable<void (int) &&>::value), "");
+static_assert((!std::__is_referenceable<void (int) const &&>::value), "");
+#endif
+
+static_assert(( std::__is_referenceable<void (int, float)>::value), "");
+#if TEST_STD_VER >= 11
+static_assert((!std::__is_referenceable<void (int, float) const>::value), "");
+static_assert((!std::__is_referenceable<void (int, float) &>::value), "");
+static_assert((!std::__is_referenceable<void (int, float) const &>::value), "");
+static_assert((!std::__is_referenceable<void (int, float) &&>::value), "");
+static_assert((!std::__is_referenceable<void (int, float) const &&>::value), "");
+#endif
+
+static_assert(( std::__is_referenceable<void (int, float, Foo &)>::value), "");
+#if TEST_STD_VER >= 11
+static_assert((!std::__is_referenceable<void (int, float, Foo &) const>::value), "");
+static_assert((!std::__is_referenceable<void (int, float, Foo &) &>::value), "");
+static_assert((!std::__is_referenceable<void (int, float, Foo &) const &>::value), "");
+static_assert((!std::__is_referenceable<void (int, float, Foo &) &&>::value), "");
+static_assert((!std::__is_referenceable<void (int, float, Foo &) const &&>::value), "");
+#endif
+
+static_assert(( std::__is_referenceable<void (...)>::value), "");
+#if TEST_STD_VER >= 11
+static_assert((!std::__is_referenceable<void (...) const>::value), "");
+static_assert((!std::__is_referenceable<void (...) &>::value), "");
+static_assert((!std::__is_referenceable<void (...) const &>::value), "");
+static_assert((!std::__is_referenceable<void (...) &&>::value), "");
+static_assert((!std::__is_referenceable<void (...) const &&>::value), "");
+#endif
+
+static_assert(( std::__is_referenceable<void (int, ...)>::value), "");
+#if TEST_STD_VER >= 11
+static_assert((!std::__is_referenceable<void (int, ...) const>::value), "");
+static_assert((!std::__is_referenceable<void (int, ...) &>::value), "");
+static_assert((!std::__is_referenceable<void (int, ...) const &>::value), "");
+static_assert((!std::__is_referenceable<void (int, ...) &&>::value), "");
+static_assert((!std::__is_referenceable<void (int, ...) const &&>::value), "");
+#endif
+
+static_assert(( std::__is_referenceable<void (int, float, ...)>::value), "");
+#if TEST_STD_VER >= 11
+static_assert((!std::__is_referenceable<void (int, float, ...) const>::value), "");
+static_assert((!std::__is_referenceable<void (int, float, ...) &>::value), "");
+static_assert((!std::__is_referenceable<void (int, float, ...) const &>::value), "");
+static_assert((!std::__is_referenceable<void (int, float, ...) &&>::value), "");
+static_assert((!std::__is_referenceable<void (int, float, ...) const &&>::value), "");
+#endif
+
+static_assert(( std::__is_referenceable<void (int, float, Foo &, ...)>::value), "");
+#if TEST_STD_VER >= 11
+static_assert((!std::__is_referenceable<void (int, float, Foo &, ...) const>::value), "");
+static_assert((!std::__is_referenceable<void (int, float, Foo &, ...) &>::value), "");
+static_assert((!std::__is_referenceable<void (int, float, Foo &, ...) const &>::value), "");
+static_assert((!std::__is_referenceable<void (int, float, Foo &, ...) &&>::value), "");
+static_assert((!std::__is_referenceable<void (int, float, Foo &, ...) const &&>::value), "");
+#endif
+
+// member functions with or without cv-qualifiers are referenceable
+static_assert(( std::__is_referenceable<void (Foo::*)()>::value), "");
+static_assert(( std::__is_referenceable<void (Foo::*)() const>::value), "");
+#if TEST_STD_VER >= 11
+static_assert(( std::__is_referenceable<void (Foo::*)() &>::value), "");
+static_assert(( std::__is_referenceable<void (Foo::*)() const &>::value), "");
+static_assert(( std::__is_referenceable<void (Foo::*)() &&>::value), "");
+static_assert(( std::__is_referenceable<void (Foo::*)() const &&>::value), "");
+#endif
+
+static_assert(( std::__is_referenceable<void (Foo::*)(int)>::value), "");
+static_assert(( std::__is_referenceable<void (Foo::*)(int) const>::value), "");
+#if TEST_STD_VER >= 11
+static_assert(( std::__is_referenceable<void (Foo::*)(int) &>::value), "");
+static_assert(( std::__is_referenceable<void (Foo::*)(int) const &>::value), "");
+static_assert(( std::__is_referenceable<void (Foo::*)(int) &&>::value), "");
+static_assert(( std::__is_referenceable<void (Foo::*)(int) const &&>::value), "");
+#endif
+
+static_assert(( std::__is_referenceable<void (Foo::*)(int, float)>::value), "");
+static_assert(( std::__is_referenceable<void (Foo::*)(int, float) const>::value), "");
+#if TEST_STD_VER >= 11
+static_assert(( std::__is_referenceable<void (Foo::*)(int, float) &>::value), "");
+static_assert(( std::__is_referenceable<void (Foo::*)(int, float) const &>::value), "");
+static_assert(( std::__is_referenceable<void (Foo::*)(int, float) &&>::value), "");
+static_assert(( std::__is_referenceable<void (Foo::*)(int, float) const &&>::value), "");
+#endif
+
+static_assert(( std::__is_referenceable<void (Foo::*)(int, float, Foo &)>::value), "");
+static_assert(( std::__is_referenceable<void (Foo::*)(int, float, Foo &) const>::value), "");
+#if TEST_STD_VER >= 11
+static_assert(( std::__is_referenceable<void (Foo::*)(int, float, Foo &) &>::value), "");
+static_assert(( std::__is_referenceable<void (Foo::*)(int, float, Foo &) const &>::value), "");
+static_assert(( std::__is_referenceable<void (Foo::*)(int, float, Foo &) &&>::value), "");
+static_assert(( std::__is_referenceable<void (Foo::*)(int, float, Foo &) const &&>::value), "");
+#endif
+
+static_assert(( std::__is_referenceable<void (Foo::*)(...)>::value), "");
+static_assert(( std::__is_referenceable<void (Foo::*)(...) const>::value), "");
+#if TEST_STD_VER >= 11
+static_assert(( std::__is_referenceable<void (Foo::*)(...) &>::value), "");
+static_assert(( std::__is_referenceable<void (Foo::*)(...) const &>::value), "");
+static_assert(( std::__is_referenceable<void (Foo::*)(...) &&>::value), "");
+static_assert(( std::__is_referenceable<void (Foo::*)(...) const &&>::value), "");
+#endif
+
+static_assert(( std::__is_referenceable<void (Foo::*)(int, ...)>::value), "");
+static_assert(( std::__is_referenceable<void (Foo::*)(int, ...) const>::value), "");
+#if TEST_STD_VER >= 11
+static_assert(( std::__is_referenceable<void (Foo::*)(int, ...) &>::value), "");
+static_assert(( std::__is_referenceable<void (Foo::*)(int, ...) const &>::value), "");
+static_assert(( std::__is_referenceable<void (Foo::*)(int, ...) &&>::value), "");
+static_assert(( std::__is_referenceable<void (Foo::*)(int, ...) const &&>::value), "");
+#endif
+
+static_assert(( std::__is_referenceable<void (Foo::*)(int, float, ...)>::value), "");
+static_assert(( std::__is_referenceable<void (Foo::*)(int, float, ...) const>::value), "");
+#if TEST_STD_VER >= 11
+static_assert(( std::__is_referenceable<void (Foo::*)(int, float, ...) &>::value), "");
+static_assert(( std::__is_referenceable<void (Foo::*)(int, float, ...) const &>::value), "");
+static_assert(( std::__is_referenceable<void (Foo::*)(int, float, ...) &&>::value), "");
+static_assert(( std::__is_referenceable<void (Foo::*)(int, float, ...) const &&>::value), "");
+#endif
+
+static_assert(( std::__is_referenceable<void (Foo::*)(int, float, Foo &, ...)>::value), "");
+static_assert(( std::__is_referenceable<void (Foo::*)(int, float, Foo &, ...) const>::value), "");
+#if TEST_STD_VER >= 11
+static_assert(( std::__is_referenceable<void (Foo::*)(int, float, Foo &, ...) &>::value), "");
+static_assert(( std::__is_referenceable<void (Foo::*)(int, float, Foo &, ...) const &>::value), "");
+static_assert(( std::__is_referenceable<void (Foo::*)(int, float, Foo &, ...) &&>::value), "");
+static_assert(( std::__is_referenceable<void (Foo::*)(int, float, Foo &, ...) const &&>::value), "");
+#endif
+
+int main () {}
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/__has_operator_addressof.pass.cpp b/test/libcxx/utilities/meta/meta.unary/meta.unary.prop/__has_operator_addressof.pass.cpp
index 1c715e04970c..1c715e04970c 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/__has_operator_addressof.pass.cpp
+++ b/test/libcxx/utilities/meta/meta.unary/meta.unary.prop/__has_operator_addressof.pass.cpp
diff --git a/test/std/utilities/meta/version.pass.cpp b/test/libcxx/utilities/meta/version.pass.cpp
index 3a1033bbb560..3a1033bbb560 100644
--- a/test/std/utilities/meta/version.pass.cpp
+++ b/test/libcxx/utilities/meta/version.pass.cpp
diff --git a/test/std/utilities/ratio/version.pass.cpp b/test/libcxx/utilities/ratio/version.pass.cpp
index 26c455fb0a9a..26c455fb0a9a 100644
--- a/test/std/utilities/ratio/version.pass.cpp
+++ b/test/libcxx/utilities/ratio/version.pass.cpp
diff --git a/test/std/utilities/template.bitset/version.pass.cpp b/test/libcxx/utilities/template.bitset/version.pass.cpp
index 5ae984c0092d..5ae984c0092d 100644
--- a/test/std/utilities/template.bitset/version.pass.cpp
+++ b/test/libcxx/utilities/template.bitset/version.pass.cpp
diff --git a/test/std/utilities/time/version.pass.cpp b/test/libcxx/utilities/time/version.pass.cpp
index bfa3f6d6797d..bfa3f6d6797d 100644
--- a/test/std/utilities/time/version.pass.cpp
+++ b/test/libcxx/utilities/time/version.pass.cpp
diff --git a/test/std/utilities/tuple/version.pass.cpp b/test/libcxx/utilities/tuple/version.pass.cpp
index 2fdbb5d2784a..2fdbb5d2784a 100644
--- a/test/std/utilities/tuple/version.pass.cpp
+++ b/test/libcxx/utilities/tuple/version.pass.cpp
diff --git a/test/std/utilities/type.index/version.pass.cpp b/test/libcxx/utilities/type.index/version.pass.cpp
index 26f462042fd3..26f462042fd3 100644
--- a/test/std/utilities/type.index/version.pass.cpp
+++ b/test/libcxx/utilities/type.index/version.pass.cpp
diff --git a/test/libcxx/utilities/utility/pairs/pairs.pair/non_trivial_copy_move_ABI.pass.cpp b/test/libcxx/utilities/utility/pairs/pairs.pair/non_trivial_copy_move_ABI.pass.cpp
new file mode 100644
index 000000000000..c012ac6265e0
--- /dev/null
+++ b/test/libcxx/utilities/utility/pairs/pairs.pair/non_trivial_copy_move_ABI.pass.cpp
@@ -0,0 +1,55 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <utility>
+
+// template <class T1, class T2> struct pair
+
+// Test that we properly provide the old non-trivial copy operations
+// when the ABI macro is defined.
+
+#define _LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR
+#include <utility>
+#include <cassert>
+
+#include "test_macros.h"
+
+#if TEST_STD_VER >= 11
+struct Dummy {
+  Dummy(Dummy const&) = delete;
+  Dummy(Dummy &&) = default;
+};
+#endif
+
+int main()
+{
+    typedef std::pair<int, short> P;
+    {
+        static_assert(std::is_copy_constructible<P>::value, "");
+        static_assert(!std::is_trivially_copy_constructible<P>::value, "");
+        static_assert(!std::is_trivially_copyable<P>::value, "");
+    }
+#if TEST_STD_VER >= 11
+    {
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(!std::is_trivially_move_constructible<P>::value, "");
+        static_assert(!std::is_trivially_copyable<P>::value, "");
+    }
+    {
+        using P1 = std::pair<Dummy, int>;
+        // These lines fail because the non-trivial constructors do not provide
+        // SFINAE.
+        // static_assert(!std::is_copy_constructible<P1>::value, "");
+        // static_assert(!std::is_trivially_copy_constructible<P1>::value, "");
+        static_assert(std::is_move_constructible<P1>::value, "");
+        static_assert(!std::is_trivially_move_constructible<P1>::value, "");
+        static_assert(!std::is_trivially_copyable<P>::value, "");
+    }
+#endif
+}
diff --git a/test/libcxx/utilities/utility/pairs/pairs.pair/trivial_copy_move_ABI.pass.cpp b/test/libcxx/utilities/utility/pairs/pairs.pair/trivial_copy_move_ABI.pass.cpp
new file mode 100644
index 000000000000..ec9cc7ec3e02
--- /dev/null
+++ b/test/libcxx/utilities/utility/pairs/pairs.pair/trivial_copy_move_ABI.pass.cpp
@@ -0,0 +1,147 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// The test fails due to the missing is_trivially_constructible intrinsic.
+// XFAIL: gcc-4.9
+
+// <utility>
+
+// template <class T1, class T2> struct pair
+
+// Test that we properly provide the trivial copy operations by default.
+
+// FreeBSD provides the old ABI. This test checks the new ABI so we need
+// to manually turn it on.
+#if defined(__FreeBSD__)
+#define _LIBCPP_ABI_UNSTABLE
+#endif
+
+#include <utility>
+#include <type_traits>
+#include <cstdlib>
+#include <cassert>
+
+#include "test_macros.h"
+
+#if defined(_LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR)
+#error Non-trivial ctor ABI macro defined
+#endif
+
+template <class T>
+struct HasTrivialABI : std::integral_constant<bool,
+    std::is_trivially_destructible<T>::value
+    && (!std::is_copy_constructible<T>::value || std::is_trivially_copy_constructible<T>::value)
+#if TEST_STD_VER >= 11
+   && (!std::is_move_constructible<T>::value || std::is_trivially_move_constructible<T>::value)
+#endif
+> {};
+
+#if TEST_STD_VER >= 11
+struct NonTrivialDtor {
+    NonTrivialDtor(NonTrivialDtor const&) = default;
+    ~NonTrivialDtor();
+};
+NonTrivialDtor::~NonTrivialDtor() {}
+static_assert(!HasTrivialABI<NonTrivialDtor>::value, "");
+
+struct NonTrivialCopy {
+    NonTrivialCopy(NonTrivialCopy const&);
+};
+NonTrivialCopy::NonTrivialCopy(NonTrivialCopy const&) {}
+static_assert(!HasTrivialABI<NonTrivialCopy>::value, "");
+
+struct NonTrivialMove {
+    NonTrivialMove(NonTrivialMove const&) = default;
+    NonTrivialMove(NonTrivialMove&&);
+};
+NonTrivialMove::NonTrivialMove(NonTrivialMove&&) {}
+static_assert(!HasTrivialABI<NonTrivialMove>::value, "");
+
+struct DeletedCopy {
+    DeletedCopy(DeletedCopy const&) = delete;
+    DeletedCopy(DeletedCopy&&) = default;
+};
+static_assert(HasTrivialABI<DeletedCopy>::value, "");
+
+struct TrivialMove {
+  TrivialMove(TrivialMove &&) = default;
+};
+static_assert(HasTrivialABI<TrivialMove>::value, "");
+
+struct Trivial {
+    Trivial(Trivial const&) = default;
+};
+static_assert(HasTrivialABI<Trivial>::value, "");
+#endif
+
+
+int main()
+{
+    {
+        typedef std::pair<int, short> P;
+        static_assert(std::is_copy_constructible<P>::value, "");
+        static_assert(HasTrivialABI<P>::value, "");
+    }
+#if TEST_STD_VER >= 11
+    {
+        typedef std::pair<int, short> P;
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(HasTrivialABI<P>::value, "");
+    }
+    {
+        using P = std::pair<NonTrivialDtor, int>;
+        static_assert(!std::is_trivially_destructible<P>::value, "");
+        static_assert(std::is_copy_constructible<P>::value, "");
+        static_assert(!std::is_trivially_copy_constructible<P>::value, "");
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(!std::is_trivially_move_constructible<P>::value, "");
+        static_assert(!HasTrivialABI<P>::value, "");
+    }
+    {
+        using P = std::pair<NonTrivialCopy, int>;
+        static_assert(std::is_copy_constructible<P>::value, "");
+        static_assert(!std::is_trivially_copy_constructible<P>::value, "");
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(!std::is_trivially_move_constructible<P>::value, "");
+        static_assert(!HasTrivialABI<P>::value, "");
+    }
+    {
+        using P = std::pair<NonTrivialMove, int>;
+        static_assert(std::is_copy_constructible<P>::value, "");
+        static_assert(std::is_trivially_copy_constructible<P>::value, "");
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(!std::is_trivially_move_constructible<P>::value, "");
+        static_assert(!HasTrivialABI<P>::value, "");
+    }
+    {
+        using P = std::pair<DeletedCopy, int>;
+        static_assert(!std::is_copy_constructible<P>::value, "");
+        static_assert(!std::is_trivially_copy_constructible<P>::value, "");
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(std::is_trivially_move_constructible<P>::value, "");
+        static_assert(HasTrivialABI<P>::value, "");
+    }
+    {
+        using P = std::pair<Trivial, int>;
+        static_assert(std::is_copy_constructible<P>::value, "");
+        static_assert(std::is_trivially_copy_constructible<P>::value, "");
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(std::is_trivially_move_constructible<P>::value, "");
+        static_assert(HasTrivialABI<P>::value, "");
+    }
+    {
+        using P = std::pair<TrivialMove, int>;
+        static_assert(!std::is_copy_constructible<P>::value, "");
+        static_assert(!std::is_trivially_copy_constructible<P>::value, "");
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(std::is_trivially_move_constructible<P>::value, "");
+        static_assert(HasTrivialABI<P>::value, "");
+    }
+#endif
+}
diff --git a/test/std/utilities/utility/version.pass.cpp b/test/libcxx/utilities/utility/version.pass.cpp
index 77d145d94457..77d145d94457 100644
--- a/test/std/utilities/utility/version.pass.cpp
+++ b/test/libcxx/utilities/utility/version.pass.cpp
diff --git a/test/lit.site.cfg.in b/test/lit.site.cfg.in
index fa25834d1110..a1ae90cb479e 100644
--- a/test/lit.site.cfg.in
+++ b/test/lit.site.cfg.in
@@ -5,6 +5,8 @@ config.libcxx_src_root          = "@LIBCXX_SOURCE_DIR@"
 config.libcxx_obj_root          = "@LIBCXX_BINARY_DIR@"
 config.cxx_library_root         = "@LIBCXX_LIBRARY_DIR@"
 config.enable_exceptions        = "@LIBCXX_ENABLE_EXCEPTIONS@"
+config.enable_experimental      = "@LIBCXX_ENABLE_EXPERIMENTAL_LIBRARY@"
+config.enable_filesystem        = "@LIBCXX_ENABLE_FILESYSTEM@"
 config.enable_rtti              = "@LIBCXX_ENABLE_RTTI@"
 config.enable_shared            = "@LIBCXX_ENABLE_SHARED@"
 config.enable_32bit             = "@LIBCXX_BUILD_32_BITS@"
@@ -20,6 +22,10 @@ config.generate_coverage        = "@LIBCXX_GENERATE_COVERAGE@"
 config.target_info              = "@LIBCXX_TARGET_INFO@"
 config.executor                 = "@LIBCXX_EXECUTOR@"
 config.llvm_unwinder            = "@LIBCXXABI_USE_LLVM_UNWINDER@"
+config.has_libatomic            = "@LIBCXX_HAS_ATOMIC_LIB@"
+config.use_libatomic            = "@LIBCXX_HAVE_CXX_ATOMICS_WITH_LIB@"
+
+config.libcxxabi_shared         = "@LIBCXXABI_ENABLE_SHARED@"
 
 # Let the main config do the real work.
 lit_config.load_config(config, "@LIBCXX_SOURCE_DIR@/test/lit.cfg")
diff --git a/test/std/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp
index 6617cd0916f3..b56d31b9d0db 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp
@@ -62,7 +62,7 @@ test_int_array()
 
 struct source {
     source() : i(0) { }
-    
+
     operator int() const { return i++; }
     mutable int i;
 };
diff --git a/test/std/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp
index 234879149ae3..449753fc263a 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp
@@ -61,6 +61,6 @@ int main()
                        random_access_iterator<const int*>(ia+s),
                        random_access_iterator<const int*>(ia),
                        random_access_iterator<const int*>(ia+s-1)));
-    
+
 #endif
 }
diff --git a/test/std/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp b/test/std/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp
index 3e1dfd17c3ff..054bc656cdb1 100644
--- a/test/std/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp
@@ -33,7 +33,7 @@ int main()
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
     int ib[] = {0, 1, 2, 3, 0, 1, 2, 3};
     const unsigned sb = sizeof(ib)/sizeof(ib[0]); ((void)sb); // unused in c++11
-    
+
     typedef input_iterator<const int*> II;
     typedef random_access_iterator<const int*>  RAI;
     typedef std::equal_to<int> EQ;
@@ -48,7 +48,7 @@ int main()
             == (std::pair<RAI, RAI>(RAI(ia+3), RAI(ib+3))));
     assert(bcp.count() > 0 && bcp.count() < sa);
     bcp.reset();
-        
+
 #ifdef HAS_FOUR_ITERATOR_VERSION
     assert(std::mismatch(II(ia), II(ia + sa), II(ib), II(ib + sb), EQ())
             == (std::pair<II, II>(II(ia+3), II(ib+3))));
diff --git a/test/std/algorithms/alg.sorting/alg.clamp/clamp.comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.clamp/clamp.comp.pass.cpp
new file mode 100644
index 000000000000..3fec12b6b53d
--- /dev/null
+++ b/test/std/algorithms/alg.sorting/alg.clamp/clamp.comp.pass.cpp
@@ -0,0 +1,127 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <algorithm>
+// XFAIL: c++98, c++03, c++11, c++14
+
+// template<class T, class Compare>
+//   const T&
+//   clamp(const T& v, const T& lo, const T& hi, Compare comp);
+
+#include <algorithm>
+#include <functional>
+#include <cassert>
+
+struct Tag {
+    Tag() : val(0), tag("Default") {}
+    Tag(int a, const char *b) : val(a), tag(b) {}
+    ~Tag() {}
+        
+    int val;
+    const char *tag;
+    };
+    
+bool eq(const Tag& rhs, const Tag& lhs) { return rhs.val == lhs.val && rhs.tag == lhs.tag; }
+// bool operator==(const Tag& rhs, const Tag& lhs) { return rhs.val == lhs.val; }
+bool comp (const Tag& rhs, const Tag& lhs) { return rhs.val <  lhs.val; }
+
+
+template <class T, class C>
+void
+test(const T& v, const T& lo, const T& hi, C c, const T& x)
+{
+    assert(&std::clamp(v, lo, hi, c) == &x);
+}
+
+int main()
+{
+    {
+    int x = 0;
+    int y = 0;
+    int z = 0;
+    test(x, y, z, std::greater<int>(), x);
+    test(y, x, z, std::greater<int>(), y);
+    }
+    {
+    int x = 0;
+    int y = 1;
+    int z = -1;
+    test(x, y, z, std::greater<int>(), x);
+    test(y, x, z, std::greater<int>(), x);
+    }
+    {
+    int x = 1;
+    int y = 0;
+    int z = 0;
+    test(x, y, z, std::greater<int>(), y);
+    test(y, x, z, std::greater<int>(), y);
+    }
+
+    {
+//  If they're all the same, we should get the value back.
+    Tag x{0, "Zero-x"};
+    Tag y{0, "Zero-y"};
+    Tag z{0, "Zero-z"};
+    assert(eq(std::clamp(x, y, z, comp), x));
+    assert(eq(std::clamp(y, x, z, comp), y));
+    }
+
+    {
+//  If it's the same as the lower bound, we get the value back.
+    Tag x{0, "Zero-x"};
+    Tag y{0, "Zero-y"};
+    Tag z{1, "One-z"};
+    assert(eq(std::clamp(x, y, z, comp), x));
+    assert(eq(std::clamp(y, x, z, comp), y));
+    }
+
+    {
+//  If it's the same as the upper bound, we get the value back.
+    Tag x{1, "One-x"};
+    Tag y{0, "Zero-y"};
+    Tag z{1, "One-z"};
+    assert(eq(std::clamp(x, y, z, comp), x));
+    assert(eq(std::clamp(z, y, x, comp), z));
+    }
+
+    {
+//  If the value is between, we should get the value back
+    Tag x{1, "One-x"};
+    Tag y{0, "Zero-y"};
+    Tag z{2, "Two-z"};
+    assert(eq(std::clamp(x, y, z, comp), x));
+    assert(eq(std::clamp(y, x, z, comp), x));
+    }
+
+    {
+//  If the value is less than the 'lo', we should get the lo back.
+    Tag x{0, "Zero-x"};
+    Tag y{1, "One-y"};
+    Tag z{2, "Two-z"};
+    assert(eq(std::clamp(x, y, z, comp), y));
+    assert(eq(std::clamp(y, x, z, comp), y));
+    }
+    {
+//  If the value is greater than 'hi', we should get hi back.
+    Tag x{2, "Two-x"};
+    Tag y{0, "Zero-y"};
+    Tag z{1, "One-z"};
+    assert(eq(std::clamp(x, y, z, comp), z));
+    assert(eq(std::clamp(y, z, x, comp), z));
+    }
+
+    {
+    typedef int T;
+    constexpr T x = 1;
+    constexpr T y = 0;
+    constexpr T z = 0;
+    static_assert(std::clamp(x, y, z, std::greater<T>()) == y, "" );
+    static_assert(std::clamp(y, x, z, std::greater<T>()) == y, "" );
+    }
+}
diff --git a/test/std/algorithms/alg.sorting/alg.clamp/clamp.pass.cpp b/test/std/algorithms/alg.sorting/alg.clamp/clamp.pass.cpp
new file mode 100644
index 000000000000..779c41827c92
--- /dev/null
+++ b/test/std/algorithms/alg.sorting/alg.clamp/clamp.pass.cpp
@@ -0,0 +1,125 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <algorithm>
+// XFAIL: c++98, c++03, c++11, c++14
+
+// template<class T>
+//   const T&
+//   clamp(const T& v, const T& lo, const T& hi);
+
+#include <algorithm>
+#include <cassert>
+
+struct Tag {
+	Tag() : val(0), tag("Default") {}
+	Tag(int a, const char *b) : val(a), tag(b) {}
+	~Tag() {}
+		
+	int val;
+	const char *tag;
+	};
+	
+bool eq(const Tag& rhs, const Tag& lhs) { return rhs.val == lhs.val && rhs.tag == lhs.tag; }
+// bool operator==(const Tag& rhs, const Tag& lhs) { return rhs.val == lhs.val; }
+bool operator< (const Tag& rhs, const Tag& lhs) { return rhs.val <  lhs.val; }
+
+template <class T>
+void
+test(const T& a, const T& lo, const T& hi, const T& x)
+{
+    assert(&std::clamp(a, lo, hi) == &x);
+}
+
+int main()
+{
+    {
+    int x = 0;
+    int y = 0;
+    int z = 0;
+    test(x, y, z, x);
+    test(y, x, z, y);
+    }
+    {
+    int x = 0;
+    int y = 1;
+    int z = 2;
+    test(x, y, z, y);
+    test(y, x, z, y);
+    }
+    {
+    int x = 1;
+    int y = 0;
+    int z = 1;
+    test(x, y, z, x);
+    test(y, x, z, x);
+    }
+
+    {
+//  If they're all the same, we should get the value back.
+    Tag x{0, "Zero-x"};
+    Tag y{0, "Zero-y"};
+    Tag z{0, "Zero-z"};
+    assert(eq(std::clamp(x, y, z), x));
+    assert(eq(std::clamp(y, x, z), y));
+    }
+
+    {
+//  If it's the same as the lower bound, we get the value back.
+    Tag x{0, "Zero-x"};
+    Tag y{0, "Zero-y"};
+    Tag z{1, "One-z"};
+    assert(eq(std::clamp(x, y, z), x));
+    assert(eq(std::clamp(y, x, z), y));
+    }
+
+    {
+//  If it's the same as the upper bound, we get the value back.
+    Tag x{1, "One-x"};
+    Tag y{0, "Zero-y"};
+    Tag z{1, "One-z"};
+    assert(eq(std::clamp(x, y, z), x));
+    assert(eq(std::clamp(z, y, x), z));
+    }
+
+    {
+//  If the value is between, we should get the value back
+    Tag x{1, "One-x"};
+    Tag y{0, "Zero-y"};
+    Tag z{2, "Two-z"};
+    assert(eq(std::clamp(x, y, z), x));
+    assert(eq(std::clamp(y, x, z), x));
+    }
+
+    {
+//  If the value is less than the 'lo', we should get the lo back.
+    Tag x{0, "Zero-x"};
+    Tag y{1, "One-y"};
+    Tag z{2, "Two-z"};
+    assert(eq(std::clamp(x, y, z), y));
+    assert(eq(std::clamp(y, x, z), y));
+    }
+    {
+//  If the value is greater than 'hi', we should get hi back.
+    Tag x{2, "Two-x"};
+    Tag y{0, "Zero-y"};
+    Tag z{1, "One-z"};
+    assert(eq(std::clamp(x, y, z), z));
+    assert(eq(std::clamp(y, z, x), z));
+    }
+
+    {
+    typedef int T;
+    constexpr T x = 1;
+    constexpr T y = 0;
+    constexpr T z = 1;
+    static_assert(std::clamp(x, y, z) == x, "" );
+    static_assert(std::clamp(y, x, z) == x, "" );
+    }
+}
diff --git a/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap_comp.pass.cpp
index 4cde1a7d32eb..0e16d9bd17c7 100644
--- a/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap_comp.pass.cpp
@@ -69,7 +69,7 @@ void test(unsigned N)
     std::random_shuffle(ia, ia+N);
     std::make_heap(ia, ia+N, std::ref(pred));
     assert(pred.count() <= 3*N);
-    assert(std::is_heap(ia, ia+N, pred));   
+    assert(std::is_heap(ia, ia+N, pred));
     }
 
     delete [] ia;
diff --git a/test/std/algorithms/alg.sorting/alg.merge/inplace_merge.pass.cpp b/test/std/algorithms/alg.sorting/alg.merge/inplace_merge.pass.cpp
index 829157353fb3..9c411730196c 100644
--- a/test/std/algorithms/alg.sorting/alg.merge/inplace_merge.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.merge/inplace_merge.pass.cpp
@@ -24,20 +24,20 @@
 struct S {
 	S() : i_(0) {}
 	S(int i) : i_(i) {}
-	
+
 	S(const S&  rhs) : i_(rhs.i_) {}
 	S(      S&& rhs) : i_(rhs.i_) { rhs.i_ = -1; }
-	
+
 	S& operator =(const S&  rhs) { i_ = rhs.i_;              return *this; }
 	S& operator =(      S&& rhs) { i_ = rhs.i_; rhs.i_ = -2; assert(this != &rhs); return *this; }
 	S& operator =(int i)         { i_ = i;                   return *this; }
-	
+
 	bool operator  <(const S&  rhs) const { return i_ < rhs.i_; }
 	bool operator ==(const S&  rhs) const { return i_ == rhs.i_; }
 	bool operator ==(int i)         const { return i_ == i; }
 
 	void set(int i) { i_ = i; }
-	
+
 	int i_;
 	};
 #endif
diff --git a/test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp
index ca6f8e40cbd3..b4d25a93e50e 100644
--- a/test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp
@@ -34,21 +34,21 @@ struct indirect_less
 struct S {
 	S() : i_(0) {}
 	S(int i) : i_(i) {}
-	
+
 	S(const S&  rhs) : i_(rhs.i_) {}
 	S(      S&& rhs) : i_(rhs.i_) { rhs.i_ = -1; }
-	
+
 	S& operator =(const S&  rhs) { i_ = rhs.i_;              return *this; }
 	S& operator =(      S&& rhs) { i_ = rhs.i_; rhs.i_ = -2; assert(this != &rhs); return *this; }
 	S& operator =(int i)         { i_ = i;                   return *this; }
-	
+
 	bool operator  <(const S&  rhs) const { return i_ < rhs.i_; }
 	bool operator  >(const S&  rhs) const { return i_ > rhs.i_; }
 	bool operator ==(const S&  rhs) const { return i_ == rhs.i_; }
 	bool operator ==(int i)         const { return i_ == i; }
 
 	void set(int i) { i_ = i; }
-	
+
 	int i_;
 	};
 
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/max_element.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/max_element.pass.cpp
index 2197b97d7f2a..3ecc250a9c8f 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/max_element.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/max_element.pass.cpp
@@ -57,13 +57,13 @@ test()
     test<Iter>(1000);
 }
 
-#if __cplusplus >= 201402L
+#if TEST_STD_VER >= 14
 constexpr int il[] = { 2, 4, 6, 8, 7, 5, 3, 1 };
 #endif
 
 void constexpr_test()
 {
-#if __cplusplus >= 201402L
+#if TEST_STD_VER >= 14
     constexpr auto p = std::max_element(il,il+8);
     static_assert ( *p == 8, "" );
 #endif
@@ -75,6 +75,6 @@ int main()
     test<bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*> >();
     test<const int*>();
-    
+
     constexpr_test ();
 }
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/max_element_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/max_element_comp.pass.cpp
index 37c181393aa6..fc88268aa84b 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/max_element_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/max_element_comp.pass.cpp
@@ -75,14 +75,14 @@ void test_eq()
     delete [] a;
 }
 
-#if __cplusplus >= 201402L
+#if TEST_STD_VER >= 14
 constexpr int il[] = { 2, 4, 6, 8, 7, 5, 3, 1 };
 struct less { constexpr bool operator ()( const int &x, const int &y) const { return x < y; }};
 #endif
 
 void constexpr_test()
 {
-#if __cplusplus >= 201402L
+#if TEST_STD_VER >= 14
     constexpr auto p = std::max_element(il, il+8, less());
     static_assert ( *p == 8, "" );
 #endif
@@ -95,6 +95,6 @@ int main()
     test<random_access_iterator<const int*> >();
     test<const int*>();
     test_eq();
-    
+
     constexpr_test();
 }
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/min_element.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/min_element.pass.cpp
index a9a9d61340f9..45dd54b1ee40 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/min_element.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/min_element.pass.cpp
@@ -57,13 +57,13 @@ test()
     test<Iter>(1000);
 }
 
-#if __cplusplus >= 201402L
+#if TEST_STD_VER >= 14
 constexpr int il[] = { 2, 4, 6, 8, 7, 5, 3, 1 };
 #endif
 
 void constexpr_test()
 {
-#if __cplusplus >= 201402L
+#if TEST_STD_VER >= 14
     constexpr auto p = std::min_element(il, il+8);
     static_assert ( *p == 1, "" );
 #endif
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/min_element_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/min_element_comp.pass.cpp
index 9517f7eac945..94ef482ddbde 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/min_element_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/min_element_comp.pass.cpp
@@ -75,14 +75,14 @@ void test_eq()
     delete [] a;
 }
 
-#if __cplusplus >= 201402L
+#if TEST_STD_VER >= 14
 constexpr int il[] = { 2, 4, 6, 8, 7, 5, 3, 1 };
 struct less { constexpr bool operator ()( const int &x, const int &y) const { return x < y; }};
 #endif
 
 void constexpr_test()
 {
-#if __cplusplus >= 201402L
+#if TEST_STD_VER >= 14
 	constexpr auto p = std::min_element(il, il+8, less());
 	static_assert(*p == 1, "");
 #endif
@@ -95,6 +95,6 @@ int main()
     test<random_access_iterator<const int*> >();
     test<const int*>();
     test_eq();
-    
+
     constexpr_test();
 }
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/minmax.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/minmax.pass.cpp
index 6ac972a2547b..8276c3a5dfd5 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/minmax.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/minmax.pass.cpp
@@ -47,7 +47,7 @@ int main()
     }
 #if _LIBCPP_STD_VER > 11
     {
-//  Note that you can't take a reference to a local var, since 
+//  Note that you can't take a reference to a local var, since
 //  its address is not a compile-time constant.
     constexpr static int x = 1;
     constexpr static int y = 0;
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/minmax_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/minmax_comp.pass.cpp
index 771c8f84a740..3289f8a7582c 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/minmax_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/minmax_comp.pass.cpp
@@ -50,7 +50,7 @@ int main()
     }
 #if _LIBCPP_STD_VER > 11
     {
-//  Note that you can't take a reference to a local var, since 
+//  Note that you can't take a reference to a local var, since
 //  its address is not a compile-time constant.
     constexpr static int x = 1;
     constexpr static int y = 0;
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/minmax_element.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/minmax_element.pass.cpp
index 915b1d176ab4..ef5474091db5 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/minmax_element.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/minmax_element.pass.cpp
@@ -74,13 +74,13 @@ test()
     }
 }
 
-#if __cplusplus >= 201402L
+#if TEST_STD_VER >= 14
 constexpr int il[] = { 2, 4, 6, 8, 7, 5, 3, 1 };
 #endif
 
 void constexpr_test()
 {
-#if __cplusplus >= 201402L
+#if TEST_STD_VER >= 14
     constexpr auto p = std::minmax_element(il, il+8);
     static_assert ( *(p.first)  == 1, "" );
     static_assert ( *(p.second) == 8, "" );
@@ -93,6 +93,6 @@ int main()
     test<bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*> >();
     test<const int*>();
-    
+
    constexpr_test();
 }
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/minmax_element_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/minmax_element_comp.pass.cpp
index d3a067fda3c5..3a0c2dbbba1b 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/minmax_element_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/minmax_element_comp.pass.cpp
@@ -79,14 +79,14 @@ test()
     }
 }
 
-#if __cplusplus >= 201402L
+#if TEST_STD_VER >= 14
 constexpr int il[] = { 2, 4, 6, 8, 7, 5, 3, 1 };
 struct less { constexpr bool operator ()( const int &x, const int &y) const { return x < y; }};
 #endif
 
 void constexpr_test()
 {
-#if __cplusplus >= 201402L
+#if TEST_STD_VER >= 14
     constexpr auto p = std::minmax_element(il, il+8, less());
     static_assert ( *(p.first)  == 1, "" );
     static_assert ( *(p.second) == 8, "" );
@@ -99,6 +99,6 @@ int main()
     test<bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*> >();
     test<const int*>();
-    
+
     constexpr_test();
 }
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/minmax_init_list_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/minmax_init_list_comp.pass.cpp
index a66b2ff27cb0..789ccef0fca4 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/minmax_init_list_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/minmax_init_list_comp.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "counting_predicates.hpp"
 
-bool all_equal(int a, int b) { return false; } // everything is equal
+bool all_equal(int, int) { return false; } // everything is equal
 
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 void test_all_equal(std::initializer_list<int> il)
diff --git a/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort.pass.cpp b/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort.pass.cpp
index 7bb43461cba4..62458eca9302 100644
--- a/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort.pass.cpp
@@ -22,13 +22,17 @@ void
 test_larger_sorts(unsigned N, unsigned M)
 {
     assert(N != 0);
+    assert(N >= M);
     int* array = new int[N];
     for (int i = 0; i < N; ++i)
         array[i] = i;
     std::random_shuffle(array, array+N);
     std::partial_sort(array, array+M, array+N);
     for (int i = 0; i < M; ++i)
+    {
+        assert(i < N); // quiet analysis warnings
         assert(array[i] == i);
+    }
     delete [] array;
 }
 
diff --git a/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort_comp.pass.cpp
index d822f6c388c1..0289cf8391f9 100644
--- a/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort_comp.pass.cpp
@@ -35,13 +35,17 @@ void
 test_larger_sorts(unsigned N, unsigned M)
 {
     assert(N != 0);
+    assert(N >= M);
     int* array = new int[N];
     for (int i = 0; i < N; ++i)
         array[i] = i;
     std::random_shuffle(array, array+N);
     std::partial_sort(array, array+M, array+N, std::greater<int>());
     for (int i = 0; i < M; ++i)
+    {
+        assert(i < N); // quiet analysis warnings
         assert(array[i] == N-i-1);
+    }
     delete [] array;
 }
 
@@ -62,6 +66,7 @@ test_larger_sorts(unsigned N)
 
 int main()
 {
+    {
     int i = 0;
     std::partial_sort(&i, &i, &i);
     assert(i == 0);
@@ -73,6 +78,7 @@ int main()
     test_larger_sorts(997);
     test_larger_sorts(1000);
     test_larger_sorts(1009);
+    }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
diff --git a/test/std/atomics/atomics.flag/atomic_flag_clear.pass.cpp b/test/std/atomics/atomics.flag/atomic_flag_clear.pass.cpp
index 3a74e13faf19..22bbbd6af535 100644
--- a/test/std/atomics/atomics.flag/atomic_flag_clear.pass.cpp
+++ b/test/std/atomics/atomics.flag/atomic_flag_clear.pass.cpp
@@ -22,13 +22,15 @@
 int main()
 {
     {
-        std::atomic_flag f(false);
+        std::atomic_flag f;
+        f.clear();
         f.test_and_set();
         atomic_flag_clear(&f);
         assert(f.test_and_set() == 0);
     }
     {
-        volatile std::atomic_flag f(false);
+        volatile std::atomic_flag f;
+        f.clear();
         f.test_and_set();
         atomic_flag_clear(&f);
         assert(f.test_and_set() == 0);
diff --git a/test/std/atomics/atomics.flag/atomic_flag_clear_explicit.pass.cpp b/test/std/atomics/atomics.flag/atomic_flag_clear_explicit.pass.cpp
index 0467384455cc..1a212c6f352a 100644
--- a/test/std/atomics/atomics.flag/atomic_flag_clear_explicit.pass.cpp
+++ b/test/std/atomics/atomics.flag/atomic_flag_clear_explicit.pass.cpp
@@ -22,38 +22,44 @@
 int main()
 {
     {
-        std::atomic_flag f(false);
-        f.test_and_set();
+        std::atomic_flag f; // uninitialized first
+        atomic_flag_clear_explicit(&f, std::memory_order_relaxed);
+        assert(f.test_and_set() == 0);
         atomic_flag_clear_explicit(&f, std::memory_order_relaxed);
         assert(f.test_and_set() == 0);
     }
     {
-        std::atomic_flag f(false);
-        f.test_and_set();
+        std::atomic_flag f;
+        atomic_flag_clear_explicit(&f, std::memory_order_release);
+        assert(f.test_and_set() == 0);
         atomic_flag_clear_explicit(&f, std::memory_order_release);
         assert(f.test_and_set() == 0);
     }
     {
-        std::atomic_flag f(false);
-        f.test_and_set();
+        std::atomic_flag f;
+        atomic_flag_clear_explicit(&f, std::memory_order_seq_cst);
+        assert(f.test_and_set() == 0);
         atomic_flag_clear_explicit(&f, std::memory_order_seq_cst);
         assert(f.test_and_set() == 0);
     }
     {
-        volatile std::atomic_flag f(false);
-        f.test_and_set();
+        volatile std::atomic_flag f;
+        atomic_flag_clear_explicit(&f, std::memory_order_relaxed);
+        assert(f.test_and_set() == 0);
         atomic_flag_clear_explicit(&f, std::memory_order_relaxed);
         assert(f.test_and_set() == 0);
     }
     {
-        volatile std::atomic_flag f(false);
-        f.test_and_set();
+        volatile std::atomic_flag f;
+        atomic_flag_clear_explicit(&f, std::memory_order_release);
+        assert(f.test_and_set() == 0);
         atomic_flag_clear_explicit(&f, std::memory_order_release);
         assert(f.test_and_set() == 0);
     }
     {
-        volatile std::atomic_flag f(false);
-        f.test_and_set();
+        volatile std::atomic_flag f;
+        atomic_flag_clear_explicit(&f, std::memory_order_seq_cst);
+        assert(f.test_and_set() == 0);
         atomic_flag_clear_explicit(&f, std::memory_order_seq_cst);
         assert(f.test_and_set() == 0);
     }
diff --git a/test/std/atomics/atomics.flag/clear.pass.cpp b/test/std/atomics/atomics.flag/clear.pass.cpp
index ea5ae45ae99a..255af8f176ea 100644
--- a/test/std/atomics/atomics.flag/clear.pass.cpp
+++ b/test/std/atomics/atomics.flag/clear.pass.cpp
@@ -22,50 +22,58 @@
 int main()
 {
     {
-        std::atomic_flag f(false);
-        f.test_and_set();
+        std::atomic_flag f; // uninitialized
+        f.clear();
+        assert(f.test_and_set() == 0);
         f.clear();
         assert(f.test_and_set() == 0);
     }
     {
-        std::atomic_flag f(false);
-        f.test_and_set();
+        std::atomic_flag f;
+        f.clear(std::memory_order_relaxed);
+        assert(f.test_and_set() == 0);
         f.clear(std::memory_order_relaxed);
         assert(f.test_and_set() == 0);
     }
     {
-        std::atomic_flag f(false);
-        f.test_and_set();
+        std::atomic_flag f;
+        f.clear(std::memory_order_release);
+        assert(f.test_and_set() == 0);
         f.clear(std::memory_order_release);
         assert(f.test_and_set() == 0);
     }
     {
-        std::atomic_flag f(false);
-        f.test_and_set();
+        std::atomic_flag f;
+        f.clear(std::memory_order_seq_cst);
+        assert(f.test_and_set() == 0);
         f.clear(std::memory_order_seq_cst);
         assert(f.test_and_set() == 0);
     }
     {
-        volatile std::atomic_flag f(false);
-        f.test_and_set();
+        volatile std::atomic_flag f;
+        f.clear();
+        assert(f.test_and_set() == 0);
         f.clear();
         assert(f.test_and_set() == 0);
     }
     {
-        volatile std::atomic_flag f(false);
-        f.test_and_set();
+        volatile std::atomic_flag f;
+        f.clear(std::memory_order_relaxed);
+        assert(f.test_and_set() == 0);
         f.clear(std::memory_order_relaxed);
         assert(f.test_and_set() == 0);
     }
     {
-        volatile std::atomic_flag f(false);
-        f.test_and_set();
+        volatile std::atomic_flag f;
+        f.clear(std::memory_order_release);
+        assert(f.test_and_set() == 0);
         f.clear(std::memory_order_release);
         assert(f.test_and_set() == 0);
     }
     {
-        volatile std::atomic_flag f(false);
-        f.test_and_set();
+        volatile std::atomic_flag f;
+        f.clear(std::memory_order_seq_cst);
+        assert(f.test_and_set() == 0);
         f.clear(std::memory_order_seq_cst);
         assert(f.test_and_set() == 0);
     }
diff --git a/test/std/atomics/atomics.lockfree/isalwayslockfree.pass.cpp b/test/std/atomics/atomics.lockfree/isalwayslockfree.pass.cpp
new file mode 100644
index 000000000000..e42e9f28448a
--- /dev/null
+++ b/test/std/atomics/atomics.lockfree/isalwayslockfree.pass.cpp
@@ -0,0 +1,101 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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: libcpp-has-no-threads, c++98, c++03, c++11, c++14
+
+// <atomic>
+
+// static constexpr bool is_always_lock_free;
+
+#include <atomic>
+#include <cassert>
+
+#if !defined(__cpp_lib_atomic_is_always_lock_free)
+# error Feature test macro missing.
+#endif
+
+template <typename T> void checkAlwaysLockFree() {
+  if (std::atomic<T>::is_always_lock_free)
+    assert(std::atomic<T>().is_lock_free());
+}
+
+int main()
+{
+// structs and unions can't be defined in the template invocation.
+// Work around this with a typedef.
+#define CHECK_ALWAYS_LOCK_FREE(T)                                              \
+  do {                                                                         \
+    typedef T type;                                                            \
+    checkAlwaysLockFree<type>();                                               \
+  } while (0)
+
+    CHECK_ALWAYS_LOCK_FREE(bool);
+    CHECK_ALWAYS_LOCK_FREE(char);
+    CHECK_ALWAYS_LOCK_FREE(signed char);
+    CHECK_ALWAYS_LOCK_FREE(unsigned char);
+    CHECK_ALWAYS_LOCK_FREE(char16_t);
+    CHECK_ALWAYS_LOCK_FREE(char32_t);
+    CHECK_ALWAYS_LOCK_FREE(wchar_t);
+    CHECK_ALWAYS_LOCK_FREE(short);
+    CHECK_ALWAYS_LOCK_FREE(unsigned short);
+    CHECK_ALWAYS_LOCK_FREE(int);
+    CHECK_ALWAYS_LOCK_FREE(unsigned int);
+    CHECK_ALWAYS_LOCK_FREE(long);
+    CHECK_ALWAYS_LOCK_FREE(unsigned long);
+    CHECK_ALWAYS_LOCK_FREE(long long);
+    CHECK_ALWAYS_LOCK_FREE(unsigned long long);
+    CHECK_ALWAYS_LOCK_FREE(std::nullptr_t);
+    CHECK_ALWAYS_LOCK_FREE(void*);
+    CHECK_ALWAYS_LOCK_FREE(float);
+    CHECK_ALWAYS_LOCK_FREE(double);
+    CHECK_ALWAYS_LOCK_FREE(long double);
+    CHECK_ALWAYS_LOCK_FREE(int __attribute__((vector_size(1 * sizeof(int)))));
+    CHECK_ALWAYS_LOCK_FREE(int __attribute__((vector_size(2 * sizeof(int)))));
+    CHECK_ALWAYS_LOCK_FREE(int __attribute__((vector_size(4 * sizeof(int)))));
+    CHECK_ALWAYS_LOCK_FREE(int __attribute__((vector_size(16 * sizeof(int)))));
+    CHECK_ALWAYS_LOCK_FREE(int __attribute__((vector_size(32 * sizeof(int)))));
+    CHECK_ALWAYS_LOCK_FREE(float __attribute__((vector_size(1 * sizeof(float)))));
+    CHECK_ALWAYS_LOCK_FREE(float __attribute__((vector_size(2 * sizeof(float)))));
+    CHECK_ALWAYS_LOCK_FREE(float __attribute__((vector_size(4 * sizeof(float)))));
+    CHECK_ALWAYS_LOCK_FREE(float __attribute__((vector_size(16 * sizeof(float)))));
+    CHECK_ALWAYS_LOCK_FREE(float __attribute__((vector_size(32 * sizeof(float)))));
+    CHECK_ALWAYS_LOCK_FREE(double __attribute__((vector_size(1 * sizeof(double)))));
+    CHECK_ALWAYS_LOCK_FREE(double __attribute__((vector_size(2 * sizeof(double)))));
+    CHECK_ALWAYS_LOCK_FREE(double __attribute__((vector_size(4 * sizeof(double)))));
+    CHECK_ALWAYS_LOCK_FREE(double __attribute__((vector_size(16 * sizeof(double)))));
+    CHECK_ALWAYS_LOCK_FREE(double __attribute__((vector_size(32 * sizeof(double)))));
+    CHECK_ALWAYS_LOCK_FREE(struct Empty {});
+    CHECK_ALWAYS_LOCK_FREE(struct OneInt { int i; });
+    CHECK_ALWAYS_LOCK_FREE(struct IntArr2 { int i[2]; });
+    CHECK_ALWAYS_LOCK_FREE(struct LLIArr2 { long long int i[2]; });
+    CHECK_ALWAYS_LOCK_FREE(struct LLIArr4 { long long int i[4]; });
+    CHECK_ALWAYS_LOCK_FREE(struct LLIArr8 { long long int i[8]; });
+    CHECK_ALWAYS_LOCK_FREE(struct LLIArr16 { long long int i[16]; });
+    CHECK_ALWAYS_LOCK_FREE(struct Padding { char c; /* padding */ long long int i; });
+    CHECK_ALWAYS_LOCK_FREE(union IntFloat { int i; float f; });
+
+    // C macro and static constexpr must be consistent.
+    static_assert(std::atomic<bool>::is_always_lock_free == (2 == ATOMIC_BOOL_LOCK_FREE));
+    static_assert(std::atomic<char>::is_always_lock_free == (2 == ATOMIC_CHAR_LOCK_FREE));
+    static_assert(std::atomic<signed char>::is_always_lock_free == (2 == ATOMIC_CHAR_LOCK_FREE));
+    static_assert(std::atomic<unsigned char>::is_always_lock_free == (2 == ATOMIC_CHAR_LOCK_FREE));
+    static_assert(std::atomic<char16_t>::is_always_lock_free == (2 == ATOMIC_CHAR16_T_LOCK_FREE));
+    static_assert(std::atomic<char32_t>::is_always_lock_free == (2 == ATOMIC_CHAR32_T_LOCK_FREE));
+    static_assert(std::atomic<wchar_t>::is_always_lock_free == (2 == ATOMIC_WCHAR_T_LOCK_FREE));
+    static_assert(std::atomic<short>::is_always_lock_free == (2 == ATOMIC_SHORT_LOCK_FREE));
+    static_assert(std::atomic<unsigned short>::is_always_lock_free == (2 == ATOMIC_SHORT_LOCK_FREE));
+    static_assert(std::atomic<int>::is_always_lock_free == (2 == ATOMIC_INT_LOCK_FREE));
+    static_assert(std::atomic<unsigned int>::is_always_lock_free == (2 == ATOMIC_INT_LOCK_FREE));
+    static_assert(std::atomic<long>::is_always_lock_free == (2 == ATOMIC_LONG_LOCK_FREE));
+    static_assert(std::atomic<unsigned long>::is_always_lock_free == (2 == ATOMIC_LONG_LOCK_FREE));
+    static_assert(std::atomic<long long>::is_always_lock_free == (2 == ATOMIC_LLONG_LOCK_FREE));
+    static_assert(std::atomic<unsigned long long>::is_always_lock_free == (2 == ATOMIC_LLONG_LOCK_FREE));
+    static_assert(std::atomic<void*>::is_always_lock_free == (2 == ATOMIC_POINTER_LOCK_FREE));
+    static_assert(std::atomic<std::nullptr_t>::is_always_lock_free == (2 == ATOMIC_POINTER_LOCK_FREE));
+}
diff --git a/test/std/atomics/atomics.lockfree/lockfree.pass.cpp b/test/std/atomics/atomics.lockfree/lockfree.pass.cpp
index a975a69a66ff..0ace9cfe7ba3 100644
--- a/test/std/atomics/atomics.lockfree/lockfree.pass.cpp
+++ b/test/std/atomics/atomics.lockfree/lockfree.pass.cpp
@@ -11,6 +11,7 @@
 
 // <atomic>
 
+// #define ATOMIC_BOOL_LOCK_FREE unspecified
 // #define ATOMIC_CHAR_LOCK_FREE unspecified
 // #define ATOMIC_CHAR16_T_LOCK_FREE unspecified
 // #define ATOMIC_CHAR32_T_LOCK_FREE unspecified
@@ -19,12 +20,16 @@
 // #define ATOMIC_INT_LOCK_FREE unspecified
 // #define ATOMIC_LONG_LOCK_FREE unspecified
 // #define ATOMIC_LLONG_LOCK_FREE unspecified
+// #define ATOMIC_POINTER_LOCK_FREE unspecified
 
 #include <atomic>
 #include <cassert>
 
 int main()
 {
+    assert(ATOMIC_BOOL_LOCK_FREE == 0 ||
+           ATOMIC_BOOL_LOCK_FREE == 1 ||
+           ATOMIC_BOOL_LOCK_FREE == 2);
     assert(ATOMIC_CHAR_LOCK_FREE == 0 ||
            ATOMIC_CHAR_LOCK_FREE == 1 ||
            ATOMIC_CHAR_LOCK_FREE == 2);
@@ -49,4 +54,7 @@ int main()
     assert(ATOMIC_LLONG_LOCK_FREE == 0 ||
            ATOMIC_LLONG_LOCK_FREE == 1 ||
            ATOMIC_LLONG_LOCK_FREE == 2);
+    assert(ATOMIC_POINTER_LOCK_FREE == 0 ||
+           ATOMIC_POINTER_LOCK_FREE == 1 ||
+           ATOMIC_POINTER_LOCK_FREE == 2);
 }
diff --git a/test/std/atomics/atomics.types.generic/address.pass.cpp b/test/std/atomics/atomics.types.generic/address.pass.cpp
index eceac25c9d94..137e46b6a155 100644
--- a/test/std/atomics/atomics.types.generic/address.pass.cpp
+++ b/test/std/atomics/atomics.types.generic/address.pass.cpp
@@ -45,13 +45,13 @@
 //     T* fetch_add(ptrdiff_t op, memory_order m = memory_order_seq_cst);
 //     T* fetch_sub(ptrdiff_t op, memory_order m = memory_order_seq_cst) volatile;
 //     T* fetch_sub(ptrdiff_t op, memory_order m = memory_order_seq_cst);
-// 
+//
 //     atomic() = default;
 //     constexpr atomic(T* desr);
 //     atomic(const atomic&) = delete;
 //     atomic& operator=(const atomic&) = delete;
 //     atomic& operator=(const atomic&) volatile = delete;
-// 
+//
 //     T* operator=(T*) volatile;
 //     T* operator=(T*);
 //     T* operator++(int) volatile;
@@ -122,8 +122,8 @@ do_test()
 
     {
         _ALIGNAS_TYPE(A) char storage[sizeof(A)] = {23};
-        A& zero = *new (storage) A();    
-        assert(zero == 0);
+        A& zero = *new (storage) A();
+        assert(zero == T(0));
         zero.~A();
     }
 }
diff --git a/test/std/atomics/atomics.types.generic/bool.pass.cpp b/test/std/atomics/atomics.types.generic/bool.pass.cpp
index 8eb04ee577cf..e85893d12b8d 100644
--- a/test/std/atomics/atomics.types.generic/bool.pass.cpp
+++ b/test/std/atomics/atomics.types.generic/bool.pass.cpp
@@ -39,7 +39,7 @@
 //                                 memory_order m = memory_order_seq_cst) volatile;
 //     bool compare_exchange_strong(T& expc, T desr,
 //                                  memory_order m = memory_order_seq_cst);
-// 
+//
 //     atomic() = default;
 //     constexpr atomic(T desr);
 //     atomic(const atomic&) = delete;
@@ -227,7 +227,7 @@ int main()
     {
         typedef std::atomic<bool> A;
         _ALIGNAS_TYPE(A) char storage[sizeof(A)] = {1};
-        A& zero = *new (storage) A();    
+        A& zero = *new (storage) A();
         assert(zero == false);
         zero.~A();
     }
diff --git a/test/std/atomics/atomics.types.generic/cstdint_typedefs.pass.cpp b/test/std/atomics/atomics.types.generic/cstdint_typedefs.pass.cpp
index a7874b9f5af4..714fbdc3926b 100644
--- a/test/std/atomics/atomics.types.generic/cstdint_typedefs.pass.cpp
+++ b/test/std/atomics/atomics.types.generic/cstdint_typedefs.pass.cpp
@@ -19,7 +19,7 @@
 // typedef atomic<uint_least32_t> atomic_uint_least32_t;
 // typedef atomic<int_least64_t>  atomic_int_least64_t;
 // typedef atomic<uint_least64_t> atomic_uint_least64_t;
-// 
+//
 // typedef atomic<int_fast8_t>   atomic_int_fast8_t;
 // typedef atomic<uint_fast8_t>  atomic_uint_fast8_t;
 // typedef atomic<int_fast16_t>  atomic_int_fast16_t;
@@ -28,7 +28,7 @@
 // typedef atomic<uint_fast32_t> atomic_uint_fast32_t;
 // typedef atomic<int_fast64_t>  atomic_int_fast64_t;
 // typedef atomic<uint_fast64_t> atomic_uint_fast64_t;
-// 
+//
 // typedef atomic<intptr_t>  atomic_intptr_t;
 // typedef atomic<uintptr_t> atomic_uintptr_t;
 // typedef atomic<size_t>    atomic_size_t;
diff --git a/test/std/atomics/atomics.types.generic/integral.pass.cpp b/test/std/atomics/atomics.types.generic/integral.pass.cpp
index 802a37c30a93..a449dc6d5f57 100644
--- a/test/std/atomics/atomics.types.generic/integral.pass.cpp
+++ b/test/std/atomics/atomics.types.generic/integral.pass.cpp
@@ -41,7 +41,7 @@
 //                                 memory_order m = memory_order_seq_cst) volatile;
 //     bool compare_exchange_strong(integral& expc, integral desr,
 //                                  memory_order m = memory_order_seq_cst);
-// 
+//
 //     integral
 //         fetch_add(integral op, memory_order m = memory_order_seq_cst) volatile;
 //     integral fetch_add(integral op, memory_order m = memory_order_seq_cst);
@@ -57,7 +57,7 @@
 //     integral
 //         fetch_xor(integral op, memory_order m = memory_order_seq_cst) volatile;
 //     integral fetch_xor(integral op, memory_order m = memory_order_seq_cst);
-// 
+//
 //     atomic() = default;
 //     constexpr atomic(integral desr);
 //     atomic(const atomic&) = delete;
@@ -65,7 +65,7 @@
 //     atomic& operator=(const atomic&) volatile = delete;
 //     integral operator=(integral desr) volatile;
 //     integral operator=(integral desr);
-// 
+//
 //     integral operator++(int) volatile;
 //     integral operator++(int);
 //     integral operator--(int) volatile;
@@ -152,7 +152,7 @@ do_test()
 
     {
         _ALIGNAS_TYPE(A) char storage[sizeof(A)] = {23};
-        A& zero = *new (storage) A();    
+        A& zero = *new (storage) A();
         assert(zero == 0);
         zero.~A();
     }
@@ -185,6 +185,15 @@ int main()
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<std::atomic_wchar_t, wchar_t>();
 
+	test<std::atomic_int8_t,    int8_t>();
+	test<std::atomic_uint8_t,  uint8_t>();
+	test<std::atomic_int16_t,   int16_t>();
+	test<std::atomic_uint16_t, uint16_t>();
+	test<std::atomic_int32_t,   int32_t>();
+	test<std::atomic_uint32_t, uint32_t>();
+	test<std::atomic_int64_t,   int64_t>();
+	test<std::atomic_uint64_t, uint64_t>();
+	
     test<volatile std::atomic_char, char>();
     test<volatile std::atomic_schar, signed char>();
     test<volatile std::atomic_uchar, unsigned char>();
@@ -201,4 +210,13 @@ int main()
     test<volatile std::atomic_char32_t, char32_t>();
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<volatile std::atomic_wchar_t, wchar_t>();
+
+	test<volatile std::atomic_int8_t,    int8_t>();
+	test<volatile std::atomic_uint8_t,  uint8_t>();
+	test<volatile std::atomic_int16_t,   int16_t>();
+	test<volatile std::atomic_uint16_t, uint16_t>();
+	test<volatile std::atomic_int32_t,   int32_t>();
+	test<volatile std::atomic_uint32_t, uint32_t>();
+	test<volatile std::atomic_int64_t,   int64_t>();
+	test<volatile std::atomic_uint64_t, uint64_t>();
 }
diff --git a/test/std/atomics/atomics.types.generic/integral_typedefs.pass.cpp b/test/std/atomics/atomics.types.generic/integral_typedefs.pass.cpp
index e8fae85fb4b3..e4deae1bf0d5 100644
--- a/test/std/atomics/atomics.types.generic/integral_typedefs.pass.cpp
+++ b/test/std/atomics/atomics.types.generic/integral_typedefs.pass.cpp
@@ -25,6 +25,18 @@
 // typedef atomic<char16_t>           atomic_char16_t;
 // typedef atomic<char32_t>           atomic_char32_t;
 // typedef atomic<wchar_t>            atomic_wchar_t;
+//
+// typedef atomic<intptr_t>           atomic_intptr_t;
+// typedef atomic<uintptr_t>          atomic_uintptr_t;
+//
+// typedef atomic<int8_t>             atomic_int8_t;
+// typedef atomic<uint8_t>            atomic_uint8_t;
+// typedef atomic<int16_t>            atomic_int16_t;
+// typedef atomic<uint16_t>           atomic_uint16_t;
+// typedef atomic<int32_t>            atomic_int32_t;
+// typedef atomic<uint32_t>           atomic_uint32_t;
+// typedef atomic<int64_t>            atomic_int64_t;
+// typedef atomic<uint64_t>           atomic_uint64_t;
 
 #include <atomic>
 #include <type_traits>
@@ -47,4 +59,17 @@ int main()
     static_assert((std::is_same<std::atomic<char16_t>, std::atomic_char16_t>::value), "");
     static_assert((std::is_same<std::atomic<char32_t>, std::atomic_char32_t>::value), "");
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+//  Added by LWG 2441
+    static_assert((std::is_same<std::atomic<intptr_t>,  std::atomic_intptr_t>::value), "");
+    static_assert((std::is_same<std::atomic<uintptr_t>, std::atomic_uintptr_t>::value), "");
+
+    static_assert((std::is_same<std::atomic<int8_t>,    std::atomic_int8_t>::value), "");
+    static_assert((std::is_same<std::atomic<uint8_t>,   std::atomic_uint8_t>::value), "");
+    static_assert((std::is_same<std::atomic<int16_t>,   std::atomic_int16_t>::value), "");
+    static_assert((std::is_same<std::atomic<uint16_t>,  std::atomic_uint16_t>::value), "");
+    static_assert((std::is_same<std::atomic<int32_t>,   std::atomic_int32_t>::value), "");
+    static_assert((std::is_same<std::atomic<uint32_t>,  std::atomic_uint32_t>::value), "");
+    static_assert((std::is_same<std::atomic<int64_t>,   std::atomic_int64_t>::value), "");
+    static_assert((std::is_same<std::atomic<uint64_t>,  std::atomic_uint64_t>::value), "");
 }
diff --git a/test/std/atomics/atomics.types.generic/trivially_copyable.fail.cpp b/test/std/atomics/atomics.types.generic/trivially_copyable.fail.cpp
index d940980e32f0..1309f3f1b78b 100644
--- a/test/std/atomics/atomics.types.generic/trivially_copyable.fail.cpp
+++ b/test/std/atomics/atomics.types.generic/trivially_copyable.fail.cpp
@@ -37,7 +37,7 @@
 //                                 memory_order m = memory_order_seq_cst) volatile noexcept;
 //     bool compare_exchange_strong(T& expc, T desr,
 //                                  memory_order m = memory_order_seq_cst) noexcept;
-// 
+//
 //     atomic() noexcept = default;
 //     constexpr atomic(T desr) noexcept;
 //     atomic(const atomic&) = delete;
diff --git a/test/std/atomics/atomics.types.generic/trivially_copyable.pass.cpp b/test/std/atomics/atomics.types.generic/trivially_copyable.pass.cpp
index 5b094f0a89c1..622643f216bd 100644
--- a/test/std/atomics/atomics.types.generic/trivially_copyable.pass.cpp
+++ b/test/std/atomics/atomics.types.generic/trivially_copyable.pass.cpp
@@ -43,7 +43,7 @@
 //                                 memory_order m = memory_order_seq_cst) volatile noexcept;
 //     bool compare_exchange_strong(T& expc, T desr,
 //                                  memory_order m = memory_order_seq_cst) noexcept;
-// 
+//
 //     atomic() noexcept = default;
 //     constexpr atomic(T desr) noexcept;
 //     atomic(const atomic&) = delete;
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong.pass.cpp
index 7b221dc6eff8..e40979f45a8f 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong.pass.cpp
@@ -15,7 +15,7 @@
 // template <class T>
 //     bool
 //     atomic_compare_exchange_strong(volatile atomic<T>* obj, T* expc, T desr);
-// 
+//
 // template <class T>
 //     bool
 //     atomic_compare_exchange_strong(atomic<T>* obj, T* expc, T desr);
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong_explicit.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong_explicit.pass.cpp
index 27de5bec4928..8ac8fc0c2d0f 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong_explicit.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong_explicit.pass.cpp
@@ -17,7 +17,7 @@
 //     atomic_compare_exchange_strong_explicit(volatile atomic<T>* obj, T* expc,
 //                                           T desr,
 //                                           memory_order s, memory_order f);
-// 
+//
 // template <class T>
 //     bool
 //     atomic_compare_exchange_strong_explicit(atomic<T>* obj, T* expc, T desr,
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak.pass.cpp
index 8c12715647e8..da0f5c3de43b 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak.pass.cpp
@@ -15,7 +15,7 @@
 // template <class T>
 //     bool
 //     atomic_compare_exchange_weak(volatile atomic<T>* obj, T* expc, T desr);
-// 
+//
 // template <class T>
 //     bool
 //     atomic_compare_exchange_weak(atomic<T>* obj, T* expc, T desr);
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak_explicit.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak_explicit.pass.cpp
index 90a93f02b978..b70446bdf7f2 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak_explicit.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak_explicit.pass.cpp
@@ -17,7 +17,7 @@
 //     atomic_compare_exchange_weak_explicit(volatile atomic<T>* obj, T* expc,
 //                                           T desr,
 //                                           memory_order s, memory_order f);
-// 
+//
 // template <class T>
 //     bool
 //     atomic_compare_exchange_weak_explicit(atomic<T>* obj, T* expc, T desr,
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange.pass.cpp
index 035d974427a4..680fe8f8287b 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange.pass.cpp
@@ -15,7 +15,7 @@
 // template <class T>
 //     T
 //     atomic_exchange(volatile atomic<T>* obj, T desr);
-// 
+//
 // template <class T>
 //     T
 //     atomic_exchange(atomic<T>* obj, T desr);
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange_explicit.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange_explicit.pass.cpp
index 4d66bb5f3b81..0df4033c8ba7 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange_explicit.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange_explicit.pass.cpp
@@ -15,7 +15,7 @@
 // template <class T>
 //     T
 //     atomic_exchange_explicit(volatile atomic<T>* obj, T desr, memory_order m);
-// 
+//
 // template <class T>
 //     T
 //     atomic_exchange_explicit(atomic<T>* obj, T desr, memory_order m);
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add.pass.cpp
index 48ff601539cf..e30543bdbf45 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add.pass.cpp
@@ -15,15 +15,15 @@
 // template <class Integral>
 //     Integral
 //     atomic_fetch_add(volatile atomic<Integral>* obj, Integral op);
-// 
+//
 // template <class Integral>
 //     Integral
 //     atomic_fetch_add(atomic<Integral>* obj, Integral op);
-// 
+//
 // template <class T>
 //     T*
 //     atomic_fetch_add(volatile atomic<T*>* obj, ptrdiff_t op);
-// 
+//
 // template <class T>
 //     T*
 //     atomic_fetch_add(atomic<T*>* obj, ptrdiff_t op);
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and.pass.cpp
index 57355d30411e..e101029bdacc 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and.pass.cpp
@@ -14,7 +14,7 @@
 // template <class Integral>
 //     Integral
 //     atomic_fetch_and(volatile atomic<Integral>* obj, Integral op);
-// 
+//
 // template <class Integral>
 //     Integral
 //     atomic_fetch_and(atomic<Integral>* obj, Integral op);
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and_explicit.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and_explicit.pass.cpp
index 26ff5f65e7db..7180c14d4ba2 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and_explicit.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and_explicit.pass.cpp
@@ -14,7 +14,7 @@
 // template <class Integral>
 //     Integral
 //     atomic_fetch_and_explicit(volatile atomic<Integral>* obj, Integral op);
-// 
+//
 // template <class Integral>
 //     Integral
 //     atomic_fetch_and_explicit(atomic<Integral>* obj, Integral op);
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or.pass.cpp
index ca44fdc3217d..241026bcf68c 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or.pass.cpp
@@ -14,7 +14,7 @@
 // template <class Integral>
 //     Integral
 //     atomic_fetch_or(volatile atomic<Integral>* obj, Integral op);
-// 
+//
 // template <class Integral>
 //     Integral
 //     atomic_fetch_or(atomic<Integral>* obj, Integral op);
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or_explicit.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or_explicit.pass.cpp
index 72bbde798cb9..c7e0b1232cf2 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or_explicit.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or_explicit.pass.cpp
@@ -14,7 +14,7 @@
 // template <class Integral>
 //     Integral
 //     atomic_fetch_or_explicit(volatile atomic<Integral>* obj, Integral op);
-// 
+//
 // template <class Integral>
 //     Integral
 //     atomic_fetch_or_explicit(atomic<Integral>* obj, Integral op);
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub.pass.cpp
index 2743040428c5..e1b12647452b 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub.pass.cpp
@@ -15,15 +15,15 @@
 // template <class Integral>
 //     Integral
 //     atomic_fetch_sub(volatile atomic<Integral>* obj, Integral op);
-// 
+//
 // template <class Integral>
 //     Integral
 //     atomic_fetch_sub(atomic<Integral>* obj, Integral op);
-// 
+//
 // template <class T>
 //     T*
 //     atomic_fetch_sub(volatile atomic<T*>* obj, ptrdiff_t op);
-// 
+//
 // template <class T>
 //     T*
 //     atomic_fetch_sub(atomic<T*>* obj, ptrdiff_t op);
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub_explicit.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub_explicit.pass.cpp
index 6e94c505fd8c..882a1f2c43b0 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub_explicit.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub_explicit.pass.cpp
@@ -20,7 +20,7 @@
 //     Integral
 //     atomic_fetch_sub_explicit(atomic<Integral>* obj, Integral op,
 //                               memory_order m);
-// 
+//
 // template <class T>
 //     T*
 //     atomic_fetch_sub_explicit(volatile atomic<T*>* obj, ptrdiff_t op,
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor.pass.cpp
index 42d57dedbd11..9306abfd06c5 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor.pass.cpp
@@ -14,7 +14,7 @@
 // template <class Integral>
 //     Integral
 //     atomic_fetch_xor(volatile atomic<Integral>* obj, Integral op);
-// 
+//
 // template <class Integral>
 //     Integral
 //     atomic_fetch_xor(atomic<Integral>* obj, Integral op);
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor_explicit.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor_explicit.pass.cpp
index 8f388fee6325..c6a80a17eef6 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor_explicit.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor_explicit.pass.cpp
@@ -14,7 +14,7 @@
 // template <class Integral>
 //     Integral
 //     atomic_fetch_xor_explicit(volatile atomic<Integral>* obj, Integral op);
-// 
+//
 // template <class Integral>
 //     Integral
 //     atomic_fetch_xor_explicit(atomic<Integral>* obj, Integral op);
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_helpers.h b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_helpers.h
index 6cbc0c35c0f5..482b7319dab2 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_helpers.h
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_helpers.h
@@ -24,10 +24,10 @@ struct UserAtomicType
     { return x.i == y.i; }
 };
 
-template < template <class TestArg> class TestFunctor > 
+template < template <class TestArg> class TestFunctor >
 struct TestEachIntegralType {
     void operator()() const {
-        TestFunctor<char>()(); 
+        TestFunctor<char>()();
         TestFunctor<signed char>()();
         TestFunctor<unsigned char>()();
         TestFunctor<short>()();
@@ -43,10 +43,18 @@ struct TestEachIntegralType {
         TestFunctor<char16_t>()();
         TestFunctor<char32_t>()();
 #endif
+		TestFunctor<  int8_t>()();
+		TestFunctor< uint8_t>()();
+		TestFunctor< int16_t>()();
+		TestFunctor<uint16_t>()();
+		TestFunctor< int32_t>()();
+		TestFunctor<uint32_t>()();
+		TestFunctor< int64_t>()();
+		TestFunctor<uint64_t>()();
     }
 };
 
-template < template <class TestArg> class TestFunctor > 
+template < template <class TestArg> class TestFunctor >
 struct TestEachAtomicType {
     void operator()() const {
         TestEachIntegralType<TestFunctor>()();
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_init.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_init.pass.cpp
index 884c02dfe7ea..2cac65a8348a 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_init.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_init.pass.cpp
@@ -15,7 +15,7 @@
 // template <class T>
 //     void
 //     atomic_init(volatile atomic<T>* obj, T desr);
-// 
+//
 // template <class T>
 //     void
 //     atomic_init(atomic<T>* obj, T desr);
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_is_lock_free.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_is_lock_free.pass.cpp
index 5d50016ed32c..27e398736b6b 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_is_lock_free.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_is_lock_free.pass.cpp
@@ -14,7 +14,7 @@
 // template <class T>
 //     bool
 //     atomic_is_lock_free(const volatile atomic<T>* obj);
-// 
+//
 // template <class T>
 //     bool
 //     atomic_is_lock_free(const atomic<T>* obj);
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load.pass.cpp
index e7b8e64b434f..b6d330cef9d8 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load.pass.cpp
@@ -15,7 +15,7 @@
 // template <class T>
 //     T
 //     atomic_load(const volatile atomic<T>* obj);
-// 
+//
 // template <class T>
 //     T
 //     atomic_load(const atomic<T>* obj);
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load_explicit.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load_explicit.pass.cpp
index 56533fa871e5..1208b79026ea 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load_explicit.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load_explicit.pass.cpp
@@ -15,7 +15,7 @@
 // template <class T>
 //     T
 //     atomic_load_explicit(const volatile atomic<T>* obj, memory_order m);
-// 
+//
 // template <class T>
 //     T
 //     atomic_load_explicit(const atomic<T>* obj, memory_order m);
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store.pass.cpp
index e61dae904116..3f8245bff6cd 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store.pass.cpp
@@ -14,7 +14,7 @@
 // template <class T>
 //     void
 //     atomic_store(volatile atomic<T>* obj, T desr);
-// 
+//
 // template <class T>
 //     void
 //     atomic_store(atomic<T>* obj, T desr);
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store_explicit.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store_explicit.pass.cpp
index e57cf8b1b323..627a04b74077 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store_explicit.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store_explicit.pass.cpp
@@ -14,7 +14,7 @@
 // template <class T>
 //     void
 //     atomic_store_explicit(volatile atomic<T>* obj, T desr, memory_order m);
-// 
+//
 // template <class T>
 //     void
 //     atomic_store_explicit(atomic<T>* obj, T desr, memory_order m);
diff --git a/test/std/containers/associative/iterator_types.pass.cpp b/test/std/containers/associative/iterator_types.pass.cpp
new file mode 100644
index 000000000000..2026219d86cb
--- /dev/null
+++ b/test/std/containers/associative/iterator_types.pass.cpp
@@ -0,0 +1,131 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+#include <map>
+#include <set>
+#include <type_traits>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+#include "test_allocator.h"
+
+
+template <class Map, class ValueTp, class PtrT, class CPtrT>
+void testMap() {
+  typedef typename Map::difference_type Diff;
+  {
+    typedef typename Map::iterator It;
+    static_assert((std::is_same<typename It::value_type, ValueTp>::value), "");
+    static_assert((std::is_same<typename It::reference, ValueTp&>::value), "");
+    static_assert((std::is_same<typename It::pointer, PtrT>::value), "");
+    static_assert((std::is_same<typename It::difference_type, Diff>::value), "");
+  }
+  {
+    typedef typename Map::const_iterator It;
+    static_assert((std::is_same<typename It::value_type, ValueTp>::value), "");
+    static_assert((std::is_same<typename It::reference, ValueTp const&>::value), "");
+    static_assert((std::is_same<typename It::pointer, CPtrT>::value), "");
+    static_assert((std::is_same<typename It::difference_type, Diff>::value), "");
+  }
+}
+
+
+template <class Set, class ValueTp, class CPtrT>
+void testSet() {
+  static_assert((std::is_same<typename Set::iterator,
+                             typename Set::const_iterator>::value), "");
+  typedef typename Set::difference_type Diff;
+  {
+    typedef typename Set::iterator It;
+    static_assert((std::is_same<typename It::value_type, ValueTp>::value), "");
+    static_assert((std::is_same<typename It::reference, ValueTp const&>::value), "");
+    static_assert((std::is_same<typename It::pointer, CPtrT>::value), "");
+    static_assert((std::is_same<typename It::difference_type, Diff>::value), "");
+
+  }
+}
+
+int main() {
+  {
+    typedef std::map<int, int> Map;
+    typedef std::pair<const int, int> ValueTp;
+    testMap<Map, ValueTp, ValueTp*, ValueTp const*>();
+  }
+  {
+    typedef std::pair<const int, int> ValueTp;
+    typedef test_allocator<ValueTp> Alloc;
+    typedef std::map<int, int, std::less<int>, Alloc> Map;
+    testMap<Map, ValueTp, ValueTp*, ValueTp const*>();
+  }
+#if TEST_STD_VER >= 11
+  {
+    typedef std::pair<const int, int> ValueTp;
+    typedef min_allocator<ValueTp> Alloc;
+    typedef std::map<int, int, std::less<int>, Alloc> Map;
+    testMap<Map, ValueTp, min_pointer<ValueTp>, min_pointer<const ValueTp>>();
+  }
+#endif
+  {
+    typedef std::multimap<int, int> Map;
+    typedef std::pair<const int, int> ValueTp;
+    testMap<Map, ValueTp, ValueTp*, ValueTp const*>();
+  }
+  {
+    typedef std::pair<const int, int> ValueTp;
+    typedef test_allocator<ValueTp> Alloc;
+    typedef std::multimap<int, int, std::less<int>, Alloc> Map;
+    testMap<Map, ValueTp, ValueTp*, ValueTp const*>();
+  }
+#if TEST_STD_VER >= 11
+  {
+    typedef std::pair<const int, int> ValueTp;
+    typedef min_allocator<ValueTp> Alloc;
+    typedef std::multimap<int, int, std::less<int>, Alloc> Map;
+    testMap<Map, ValueTp, min_pointer<ValueTp>, min_pointer<const ValueTp>>();
+  }
+#endif
+  {
+    typedef int ValueTp;
+    typedef std::set<ValueTp> Set;
+    testSet<Set, ValueTp, ValueTp const*>();
+  }
+  {
+    typedef int ValueTp;
+    typedef test_allocator<ValueTp> Alloc;
+    typedef std::set<ValueTp, std::less<ValueTp>, Alloc> Set;
+    testSet<Set, ValueTp, ValueTp const*>();
+  }
+#if TEST_STD_VER >= 11
+  {
+    typedef int ValueTp;
+    typedef min_allocator<ValueTp> Alloc;
+    typedef std::set<ValueTp, std::less<ValueTp>, Alloc> Set;
+    testSet<Set, ValueTp, min_pointer<const ValueTp>>();
+  }
+#endif
+  {
+    typedef int ValueTp;
+    typedef std::multiset<ValueTp> Set;
+    testSet<Set, ValueTp, ValueTp const*>();
+  }
+  {
+    typedef int ValueTp;
+    typedef test_allocator<ValueTp> Alloc;
+    typedef std::multiset<ValueTp, std::less<ValueTp>, Alloc> Set;
+    testSet<Set, ValueTp, ValueTp const*>();
+  }
+#if TEST_STD_VER >= 11
+  {
+    typedef int ValueTp;
+    typedef min_allocator<ValueTp> Alloc;
+    typedef std::multiset<ValueTp, std::less<ValueTp>, Alloc> Set;
+    testSet<Set, ValueTp, min_pointer<const ValueTp>>();
+  }
+#endif
+}
diff --git a/test/std/containers/associative/map/PR28469_undefined_behavior_segfault.sh.cpp b/test/std/containers/associative/map/PR28469_undefined_behavior_segfault.sh.cpp
new file mode 100644
index 000000000000..32d34d90d7f8
--- /dev/null
+++ b/test/std/containers/associative/map/PR28469_undefined_behavior_segfault.sh.cpp
@@ -0,0 +1,31 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// RUN: %build -O2
+// RUN: %run
+
+// <map>
+
+// Previously this code caused a segfault when compiled at -O2 due to undefined
+// behavior in __tree. See https://llvm.org/bugs/show_bug.cgi?id=28469
+
+#include <functional>
+#include <map>
+
+void dummy() {}
+
+struct F {
+    std::map<int, std::function<void()> > m;
+    F() { m[42] = &dummy; }
+};
+
+int main() {
+    F f;
+    f = F();
+}
diff --git a/test/std/containers/associative/map/compare.pass.cpp b/test/std/containers/associative/map/compare.pass.cpp
index 26ac7af7d908..9d1c13d7b8e6 100644
--- a/test/std/containers/associative/map/compare.pass.cpp
+++ b/test/std/containers/associative/map/compare.pass.cpp
@@ -44,7 +44,7 @@ int main()
         MapT map;
         IterBool result = map.insert(std::make_pair(Key(0), 42));
         assert(result.second);
-        assert(result.first->second = 42);
+        assert(result.first->second == 42);
         IterBool result2 = map.insert(std::make_pair(Key(0), 43));
         assert(!result2.second);
         assert(map[Key(0)] == 42);
diff --git a/test/std/containers/associative/map/incomplete_type.pass.cpp b/test/std/containers/associative/map/incomplete_type.pass.cpp
new file mode 100644
index 000000000000..84c2451ce087
--- /dev/null
+++ b/test/std/containers/associative/map/incomplete_type.pass.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <map>
+
+// Check that std::map and it's iterators can be instantiated with an incomplete
+// type.
+
+#include <map>
+
+struct A {
+    typedef std::map<A, A> Map;
+    int data;
+    Map m;
+    Map::iterator it;
+    Map::const_iterator cit;
+};
+
+inline bool operator==(A const& L, A const& R) { return &L == &R; }
+inline bool operator<(A const& L, A const& R)  { return L.data < R.data; }
+int main() {
+    A a;
+}
diff --git a/test/std/containers/associative/map/map.access/at.pass.cpp b/test/std/containers/associative/map/map.access/at.pass.cpp
index 0da28507fce3..c5f77bf5f0fb 100644
--- a/test/std/containers/associative/map/map.access/at.pass.cpp
+++ b/test/std/containers/associative/map/map.access/at.pass.cpp
@@ -86,7 +86,7 @@ int main()
         assert(m.at(8) == 8.5);
         assert(m.size() == 7);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::pair<const int, double> V;
         V ar[] =
diff --git a/test/std/containers/associative/map/map.access/empty.pass.cpp b/test/std/containers/associative/map/map.access/empty.pass.cpp
index b11e94c8042c..17b9cfd4ec11 100644
--- a/test/std/containers/associative/map/map.access/empty.pass.cpp
+++ b/test/std/containers/associative/map/map.access/empty.pass.cpp
@@ -29,7 +29,7 @@ int main()
     m.clear();
     assert(m.empty());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::map<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
     M m;
diff --git a/test/std/containers/associative/map/map.access/index_key.pass.cpp b/test/std/containers/associative/map/map.access/index_key.pass.cpp
index ab1144c60afd..3b1c21fd5da4 100644
--- a/test/std/containers/associative/map/map.access/index_key.pass.cpp
+++ b/test/std/containers/associative/map/map.access/index_key.pass.cpp
@@ -16,8 +16,13 @@
 #include <map>
 #include <cassert>
 
+#include "test_macros.h"
+#include "count_new.hpp"
 #include "min_allocator.h"
 #include "private_constructor.hpp"
+#if TEST_STD_VER >= 11
+#include "container_test_types.h"
+#endif
 
 int main()
 {
@@ -46,7 +51,7 @@ int main()
     assert(m[6] == 6.5);
     assert(m.size() == 8);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::pair<const int, double> V;
     V ar[] =
@@ -73,8 +78,42 @@ int main()
     assert(m[6] == 6.5);
     assert(m.size() == 8);
     }
+    {
+        // Use "container_test_types.h" to check what arguments get passed
+        // to the allocator for operator[]
+        using Container = TCT::map<>;
+        using Key = Container::key_type;
+        using MappedType = Container::mapped_type;
+        using ValueTp = Container::value_type;
+        ConstructController* cc = getConstructController();
+        cc->reset();
+        {
+            Container c;
+            const Key k(1);
+            cc->expect<std::piecewise_construct_t const&, std::tuple<Key const&>&&, std::tuple<>&&>();
+            MappedType& mref = c[k];
+            assert(!cc->unchecked());
+            {
+                DisableAllocationGuard g;
+                MappedType& mref2 = c[k];
+                assert(&mref == &mref2);
+            }
+        }
+        {
+            Container c;
+            Key k(1);
+            cc->expect<std::piecewise_construct_t const&, std::tuple<Key const&>&&, std::tuple<>&&>();
+            MappedType& mref = c[k];
+            assert(!cc->unchecked());
+            {
+                DisableAllocationGuard g;
+                MappedType& mref2 = c[k];
+                assert(&mref == &mref2);
+            }
+        }
+    }
 #endif
-#if _LIBCPP_STD_VER > 11
+#if TEST_STD_VER > 11
     {
     typedef std::pair<const int, double> V;
     V ar[] =
diff --git a/test/std/containers/associative/map/map.access/index_rv_key.pass.cpp b/test/std/containers/associative/map/map.access/index_rv_key.pass.cpp
index 6511dcc85f53..e5580bca3955 100644
--- a/test/std/containers/associative/map/map.access/index_rv_key.pass.cpp
+++ b/test/std/containers/associative/map/map.access/index_rv_key.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <map>
 
 // class map
@@ -17,12 +19,13 @@
 #include <cassert>
 
 #include "test_macros.h"
+#include "count_new.hpp"
 #include "MoveOnly.h"
 #include "min_allocator.h"
+#include "container_test_types.h"
 
 int main()
 {
-#if TEST_STD_VER >= 11
     {
     std::map<MoveOnly, double> m;
     assert(m.size() == 0);
@@ -52,5 +55,27 @@ int main()
     assert(m[6] == 6.5);
     assert(m.size() == 2);
     }
-#endif
+    {
+        // Use "container_test_types.h" to check what arguments get passed
+        // to the allocator for operator[]
+        using Container = TCT::map<>;
+        using Key = Container::key_type;
+        using MappedType = Container::mapped_type;
+        using ValueTp = Container::value_type;
+        ConstructController* cc = getConstructController();
+        cc->reset();
+        {
+            Container c;
+            Key k(1);
+            cc->expect<std::piecewise_construct_t const&, std::tuple<Key &&>&&, std::tuple<>&&>();
+            MappedType& mref = c[std::move(k)];
+            assert(!cc->unchecked());
+            {
+                Key k2(1);
+                DisableAllocationGuard g;
+                MappedType& mref2 = c[std::move(k2)];
+                assert(&mref == &mref2);
+            }
+        }
+    }
 }
diff --git a/test/std/containers/associative/map/map.access/iterator.pass.cpp b/test/std/containers/associative/map/map.access/iterator.pass.cpp
index 552e87d8fc8d..4f66eb6a8e31 100644
--- a/test/std/containers/associative/map/map.access/iterator.pass.cpp
+++ b/test/std/containers/associative/map/map.access/iterator.pass.cpp
@@ -119,7 +119,7 @@ int main()
             assert(i->second == 1);
         }
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::pair<const int, double> V;
         V ar[] =
diff --git a/test/std/containers/associative/map/map.access/max_size.pass.cpp b/test/std/containers/associative/map/map.access/max_size.pass.cpp
index 551120d331e1..c67d8b1f674d 100644
--- a/test/std/containers/associative/map/map.access/max_size.pass.cpp
+++ b/test/std/containers/associative/map/map.access/max_size.pass.cpp
@@ -25,7 +25,7 @@ int main()
     M m;
     assert(m.max_size() != 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::map<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
     M m;
diff --git a/test/std/containers/associative/map/map.access/size.pass.cpp b/test/std/containers/associative/map/map.access/size.pass.cpp
index 07c12322a460..b9d56167a4b0 100644
--- a/test/std/containers/associative/map/map.access/size.pass.cpp
+++ b/test/std/containers/associative/map/map.access/size.pass.cpp
@@ -37,7 +37,7 @@ int main()
     m.erase(m.begin());
     assert(m.size() == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::map<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
     M m;
diff --git a/test/std/containers/associative/map/map.cons/alloc.pass.cpp b/test/std/containers/associative/map/map.cons/alloc.pass.cpp
index 2292c47ef74b..6ff102e6873c 100644
--- a/test/std/containers/associative/map/map.cons/alloc.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/alloc.pass.cpp
@@ -29,7 +29,7 @@ int main()
     assert(m.begin() == m.end());
     assert(m.get_allocator() == A(5));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::less<int> C;
     typedef min_allocator<std::pair<const int, double> > A;
diff --git a/test/std/containers/associative/map/map.cons/assign_initializer_list.pass.cpp b/test/std/containers/associative/map/map.cons/assign_initializer_list.pass.cpp
index 482d1acff840..679600662fda 100644
--- a/test/std/containers/associative/map/map.cons/assign_initializer_list.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/assign_initializer_list.pass.cpp
@@ -45,7 +45,7 @@ int main()
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::pair<const int, double> V;
     std::map<int, double, std::less<int>, min_allocator<V>> m =
diff --git a/test/std/containers/associative/map/map.cons/compare.pass.cpp b/test/std/containers/associative/map/map.cons/compare.pass.cpp
index 5a213c8e8b8f..5d8d5e252507 100644
--- a/test/std/containers/associative/map/map.cons/compare.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/compare.pass.cpp
@@ -28,7 +28,7 @@ int main()
     assert(m.begin() == m.end());
     assert(m.key_comp() == C(3));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef test_compare<std::less<int> > C;
     std::map<int, double, C, min_allocator<std::pair<const int, double>>> m(C(3));
diff --git a/test/std/containers/associative/map/map.cons/compare_alloc.pass.cpp b/test/std/containers/associative/map/map.cons/compare_alloc.pass.cpp
index 56b3c3315e08..ea1374a53dac 100644
--- a/test/std/containers/associative/map/map.cons/compare_alloc.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/compare_alloc.pass.cpp
@@ -31,7 +31,7 @@ int main()
     assert(m.key_comp() == C(4));
     assert(m.get_allocator() == A(5));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef test_compare<std::less<int> > C;
     typedef min_allocator<std::pair<const int, double> > A;
diff --git a/test/std/containers/associative/map/map.cons/compare_copy_constructible.fail.cpp b/test/std/containers/associative/map/map.cons/compare_copy_constructible.fail.cpp
new file mode 100644
index 000000000000..81ccba3bbc96
--- /dev/null
+++ b/test/std/containers/associative/map/map.cons/compare_copy_constructible.fail.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <map>
+
+// Check that std::map fails to instantiate if the comparison predicate is 
+// not copy-constructible. This is LWG issue 2436
+
+#include <map>
+
+template <class T>
+struct Comp {
+	bool operator () (const T& lhs, const T& rhs) const { return lhs < rhs; }
+
+	Comp () {}
+private:
+	Comp (const Comp &); // declared but not defined
+	};
+
+
+int main() {
+	std::map<int, int, Comp<int> > m;
+}
diff --git a/test/std/containers/associative/map/map.cons/copy.pass.cpp b/test/std/containers/associative/map/map.cons/copy.pass.cpp
index be5274133082..a1de1b13aed2 100644
--- a/test/std/containers/associative/map/map.cons/copy.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/copy.pass.cpp
@@ -92,7 +92,7 @@ int main()
         assert(*next(mo.begin(), 2) == V(3, 1));
     }
 #endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::pair<const int, double> V;
         V ar[] =
diff --git a/test/std/containers/associative/map/map.cons/copy_alloc.pass.cpp b/test/std/containers/associative/map/map.cons/copy_alloc.pass.cpp
index fcbe5976d6da..8a9f7c86a2c7 100644
--- a/test/std/containers/associative/map/map.cons/copy_alloc.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/copy_alloc.pass.cpp
@@ -56,7 +56,7 @@ int main()
     assert(*next(mo.begin()) == V(2, 1));
     assert(*next(mo.begin(), 2) == V(3, 1));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::pair<const int, double> V;
     V ar[] =
diff --git a/test/std/containers/associative/map/map.cons/copy_assign.pass.cpp b/test/std/containers/associative/map/map.cons/copy_assign.pass.cpp
index a1bcb30f4294..fc6641ae34b9 100644
--- a/test/std/containers/associative/map/map.cons/copy_assign.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/copy_assign.pass.cpp
@@ -107,7 +107,7 @@ int main()
         assert(*next(mo.begin()) == V(2, 1));
         assert(*next(mo.begin(), 2) == V(3, 1));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::pair<const int, double> V;
         V ar[] =
diff --git a/test/std/containers/associative/map/map.cons/default.pass.cpp b/test/std/containers/associative/map/map.cons/default.pass.cpp
index 1832a32fffb3..265c59ef24cd 100644
--- a/test/std/containers/associative/map/map.cons/default.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/default.pass.cpp
@@ -25,7 +25,7 @@ int main()
     assert(m.empty());
     assert(m.begin() == m.end());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     std::map<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> m;
     assert(m.empty());
diff --git a/test/std/containers/associative/map/map.cons/default_noexcept.pass.cpp b/test/std/containers/associative/map/map.cons/default_noexcept.pass.cpp
index dedc89bd435e..817f1207ac94 100644
--- a/test/std/containers/associative/map/map.cons/default_noexcept.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/default_noexcept.pass.cpp
@@ -17,9 +17,12 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <map>
 #include <cassert>
 
+#include "test_macros.h"
 #include "MoveOnly.h"
 #include "test_allocator.h"
 
@@ -28,19 +31,19 @@ struct some_comp
 {
     typedef T value_type;
     some_comp();
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     typedef std::pair<const MoveOnly, MoveOnly> V;
     {
         typedef std::map<MoveOnly, MoveOnly> C;
-        static_assert(std::is_nothrow_default_constructible<C>::value, "");
+        LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
     }
     {
         typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<V>> C;
-        static_assert(std::is_nothrow_default_constructible<C>::value, "");
+        LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
     }
     {
         typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<V>> C;
@@ -50,5 +53,4 @@ int main()
         typedef std::map<MoveOnly, MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/associative/map/map.cons/dtor_noexcept.pass.cpp b/test/std/containers/associative/map/map.cons/dtor_noexcept.pass.cpp
index 9baa19b53d05..efdf5a2ed184 100644
--- a/test/std/containers/associative/map/map.cons/dtor_noexcept.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/dtor_noexcept.pass.cpp
@@ -11,26 +11,24 @@
 
 // ~map() // implied noexcept;
 
+// UNSUPPORTED: c++98, c++03
+
 #include <map>
 #include <cassert>
 
 #include "MoveOnly.h"
 #include "test_allocator.h"
 
-#if __has_feature(cxx_noexcept)
-
 template <class T>
 struct some_comp
 {
     typedef T value_type;
     ~some_comp() noexcept(false);
+    bool operator()(const T&, const T&) const noexcept { return false; }
 };
 
-#endif
-
 int main()
 {
-#if __has_feature(cxx_noexcept)
     typedef std::pair<const MoveOnly, MoveOnly> V;
     {
         typedef std::map<MoveOnly, MoveOnly> C;
@@ -48,5 +46,4 @@ int main()
         typedef std::map<MoveOnly, MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/associative/map/map.cons/initializer_list.pass.cpp b/test/std/containers/associative/map/map.cons/initializer_list.pass.cpp
index 196943653a14..c55d18f54094 100644
--- a/test/std/containers/associative/map/map.cons/initializer_list.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/initializer_list.pass.cpp
@@ -41,7 +41,7 @@ int main()
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::pair<const int, double> V;
     std::map<int, double, std::less<int>, min_allocator<V>> m =
diff --git a/test/std/containers/associative/map/map.cons/initializer_list_compare.pass.cpp b/test/std/containers/associative/map/map.cons/initializer_list_compare.pass.cpp
index 08f8a529f030..3133eb2e0dd6 100644
--- a/test/std/containers/associative/map/map.cons/initializer_list_compare.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/initializer_list_compare.pass.cpp
@@ -42,7 +42,7 @@ int main()
     assert(*next(m.begin(), 2) == V(3, 1));
     assert(m.key_comp() == C(3));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::pair<const int, double> V;
     typedef test_compare<std::less<int> > C;
diff --git a/test/std/containers/associative/map/map.cons/initializer_list_compare_alloc.pass.cpp b/test/std/containers/associative/map/map.cons/initializer_list_compare_alloc.pass.cpp
index 765428a631e5..1210fe0e49e1 100644
--- a/test/std/containers/associative/map/map.cons/initializer_list_compare_alloc.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/initializer_list_compare_alloc.pass.cpp
@@ -45,7 +45,7 @@ int main()
     assert(m.key_comp() == C(3));
     assert(m.get_allocator() == A(6));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::pair<const int, double> V;
     typedef test_compare<std::less<int> > C;
diff --git a/test/std/containers/associative/map/map.cons/iter_iter.pass.cpp b/test/std/containers/associative/map/map.cons/iter_iter.pass.cpp
index c1029af6889e..48610f3b3e58 100644
--- a/test/std/containers/associative/map/map.cons/iter_iter.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/iter_iter.pass.cpp
@@ -42,7 +42,7 @@ int main()
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::pair<const int, double> V;
     V ar[] =
diff --git a/test/std/containers/associative/map/map.cons/iter_iter_comp.pass.cpp b/test/std/containers/associative/map/map.cons/iter_iter_comp.pass.cpp
index 837fa8c6cdea..1389f71449c8 100644
--- a/test/std/containers/associative/map/map.cons/iter_iter_comp.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/iter_iter_comp.pass.cpp
@@ -45,7 +45,7 @@ int main()
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::pair<const int, double> V;
     V ar[] =
diff --git a/test/std/containers/associative/map/map.cons/iter_iter_comp_alloc.pass.cpp b/test/std/containers/associative/map/map.cons/iter_iter_comp_alloc.pass.cpp
index 67fb5d644762..42376e268332 100644
--- a/test/std/containers/associative/map/map.cons/iter_iter_comp_alloc.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/iter_iter_comp_alloc.pass.cpp
@@ -49,7 +49,7 @@ int main()
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::pair<const int, double> V;
     V ar[] =
diff --git a/test/std/containers/associative/map/map.cons/move.pass.cpp b/test/std/containers/associative/map/map.cons/move.pass.cpp
index c06f2ee5021b..2d19b88bdda8 100644
--- a/test/std/containers/associative/map/map.cons/move.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/move.pass.cpp
@@ -69,7 +69,7 @@ int main()
         assert(mo.size() == 0);
         assert(distance(mo.begin(), mo.end()) == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef test_compare<std::less<int> > C;
         typedef min_allocator<V> A;
diff --git a/test/std/containers/associative/map/map.cons/move_alloc.pass.cpp b/test/std/containers/associative/map/map.cons/move_alloc.pass.cpp
index e5d43f266c08..4ccf56118aec 100644
--- a/test/std/containers/associative/map/map.cons/move_alloc.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/move_alloc.pass.cpp
@@ -169,7 +169,7 @@ int main()
 
             M m1(I(a1), I(a1+num), C(), A());
             assert(Counter_base::gConstructed == num+3);
-        
+
             M m2(m1);
             assert(m2 == m1);
             assert(Counter_base::gConstructed == num+6);
@@ -187,9 +187,9 @@ int main()
             }
             assert(Counter_base::gConstructed == num+3);
         }
-        assert(Counter_base::gConstructed == 0);            
+        assert(Counter_base::gConstructed == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
         typedef std::pair<const MoveOnly, MoveOnly> VC;
diff --git a/test/std/containers/associative/map/map.cons/move_assign.pass.cpp b/test/std/containers/associative/map/map.cons/move_assign.pass.cpp
index 8ae8265cdc12..09b41d3b130b 100644
--- a/test/std/containers/associative/map/map.cons/move_assign.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/move_assign.pass.cpp
@@ -144,7 +144,7 @@ int main()
         assert(m3.key_comp() == C(5));
         assert(m1.empty());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
         typedef std::pair<const MoveOnly, MoveOnly> VC;
diff --git a/test/std/containers/associative/map/map.cons/move_assign_noexcept.pass.cpp b/test/std/containers/associative/map/map.cons/move_assign_noexcept.pass.cpp
index 3b28118b5b1e..95ddf6dcb82f 100644
--- a/test/std/containers/associative/map/map.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/move_assign_noexcept.pass.cpp
@@ -17,6 +17,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <map>
 #include <cassert>
 
@@ -28,11 +30,11 @@ struct some_comp
 {
     typedef T value_type;
     some_comp& operator=(const some_comp&);
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     typedef std::pair<const MoveOnly, MoveOnly> V;
     {
         typedef std::map<MoveOnly, MoveOnly> C;
@@ -50,5 +52,4 @@ int main()
         typedef std::map<MoveOnly, MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/associative/map/map.cons/move_noexcept.pass.cpp b/test/std/containers/associative/map/map.cons/move_noexcept.pass.cpp
index 0f1fd396639e..1c2a242edf43 100644
--- a/test/std/containers/associative/map/map.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/move_noexcept.pass.cpp
@@ -15,6 +15,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <map>
 #include <cassert>
 
@@ -26,11 +28,11 @@ struct some_comp
 {
     typedef T value_type;
     some_comp(const some_comp&);
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     typedef std::pair<const MoveOnly, MoveOnly> V;
     {
         typedef std::map<MoveOnly, MoveOnly> C;
@@ -48,5 +50,4 @@ int main()
         typedef std::map<MoveOnly, MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/associative/map/map.modifiers/clear.pass.cpp b/test/std/containers/associative/map/map.modifiers/clear.pass.cpp
index c37499df307a..1f36a6f10cb0 100644
--- a/test/std/containers/associative/map/map.modifiers/clear.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/clear.pass.cpp
@@ -39,7 +39,7 @@ int main()
         m.clear();
         assert(m.size() == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::map<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
         typedef std::pair<int, double> P;
diff --git a/test/std/containers/associative/map/map.modifiers/emplace.pass.cpp b/test/std/containers/associative/map/map.modifiers/emplace.pass.cpp
index 81846c6647c6..63d014fe8cc5 100644
--- a/test/std/containers/associative/map/map.modifiers/emplace.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/emplace.pass.cpp
@@ -92,7 +92,7 @@ int main()
         assert(m.begin()->first == 2);
         assert(m.begin()->second == 3.5);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::map<int, DefaultOnly, std::less<int>, min_allocator<std::pair<const int, DefaultOnly>>> M;
         typedef std::pair<M::iterator, bool> R;
diff --git a/test/std/containers/associative/map/map.modifiers/emplace_hint.pass.cpp b/test/std/containers/associative/map/map.modifiers/emplace_hint.pass.cpp
index 15f74b17e786..319a239525ad 100644
--- a/test/std/containers/associative/map/map.modifiers/emplace_hint.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/emplace_hint.pass.cpp
@@ -64,7 +64,7 @@ int main()
         assert(m.size() == 1);
         assert(m.begin()->first == 2);
         assert(m.begin()->second == Emplaceable());
-        r = m.emplace_hint(m.end(), std::piecewise_construct, 
+        r = m.emplace_hint(m.end(), std::piecewise_construct,
                                     std::forward_as_tuple(1),
                                     std::forward_as_tuple(2, 3.5));
         assert(r == m.begin());
@@ -89,7 +89,7 @@ int main()
         assert(m.begin()->first == 2);
         assert(m.begin()->second == 3.5);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::map<int, DefaultOnly, std::less<int>, min_allocator<std::pair<const int, DefaultOnly>>> M;
         typedef M::iterator R;
@@ -130,7 +130,7 @@ int main()
         assert(m.size() == 1);
         assert(m.begin()->first == 2);
         assert(m.begin()->second == Emplaceable());
-        r = m.emplace_hint(m.end(), std::piecewise_construct, 
+        r = m.emplace_hint(m.end(), std::piecewise_construct,
                                     std::forward_as_tuple(1),
                                     std::forward_as_tuple(2, 3.5));
         assert(r == m.begin());
diff --git a/test/std/containers/associative/map/map.modifiers/erase_iter.pass.cpp b/test/std/containers/associative/map/map.modifiers/erase_iter.pass.cpp
index 15c5ce041b68..cd65c4302af7 100644
--- a/test/std/containers/associative/map/map.modifiers/erase_iter.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/erase_iter.pass.cpp
@@ -134,7 +134,7 @@ int main()
         assert(i == m.begin());
         assert(i == m.end());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::map<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
         typedef std::pair<int, double> P;
@@ -242,7 +242,7 @@ int main()
         assert(i == m.end());
     }
 #endif
-#if __cplusplus >= 201402L
+#if TEST_STD_VER >= 14
     {
     //  This is LWG #2059
         typedef TemplateConstructor T;
diff --git a/test/std/containers/associative/map/map.modifiers/erase_iter_iter.pass.cpp b/test/std/containers/associative/map/map.modifiers/erase_iter_iter.pass.cpp
index 1b49956d8a5a..144cfac2ccb5 100644
--- a/test/std/containers/associative/map/map.modifiers/erase_iter_iter.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/erase_iter_iter.pass.cpp
@@ -86,7 +86,7 @@ int main()
         assert(i == m.begin());
         assert(i == m.end());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::map<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
         typedef std::pair<int, double> P;
diff --git a/test/std/containers/associative/map/map.modifiers/erase_key.pass.cpp b/test/std/containers/associative/map/map.modifiers/erase_key.pass.cpp
index e41f5129140e..c1b31e78d3ef 100644
--- a/test/std/containers/associative/map/map.modifiers/erase_key.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/erase_key.pass.cpp
@@ -145,7 +145,7 @@ int main()
         assert(m.size() == 0);
         assert(s == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::map<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
         typedef std::pair<int, double> P;
diff --git a/test/std/containers/associative/map/map.modifiers/insert_and_emplace_allocator_requirements.pass.cpp b/test/std/containers/associative/map/map.modifiers/insert_and_emplace_allocator_requirements.pass.cpp
new file mode 100644
index 000000000000..d98047d02e7d
--- /dev/null
+++ b/test/std/containers/associative/map/map.modifiers/insert_and_emplace_allocator_requirements.pass.cpp
@@ -0,0 +1,31 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <map>
+
+// class map
+
+// insert(...);
+// emplace(...);
+// emplace_hint(...);
+
+// UNSUPPORTED: c++98, c++03
+
+#include <map>
+
+#include "container_test_types.h"
+#include "../../../map_allocator_requirement_test_templates.h"
+
+int main()
+{
+  testMapInsert<TCT::map<> >();
+  testMapInsertHint<TCT::map<> >();
+  testMapEmplace<TCT::map<> >();
+  testMapEmplaceHint<TCT::map<> >();
+}
diff --git a/test/std/containers/associative/map/map.modifiers/insert_cv.pass.cpp b/test/std/containers/associative/map/map.modifiers/insert_cv.pass.cpp
index 3d28242fd322..e2ffcba375fa 100644
--- a/test/std/containers/associative/map/map.modifiers/insert_cv.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/insert_cv.pass.cpp
@@ -16,74 +16,57 @@
 #include <map>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+template <class Container>
+void do_insert_cv_test()
 {
-    {
-        typedef std::map<int, double> M;
-        typedef std::pair<M::iterator, bool> R;
-        M m;
-        R r = m.insert(M::value_type(2, 2.5));
-        assert(r.second);
-        assert(r.first == m.begin());
-        assert(m.size() == 1);
-        assert(r.first->first == 2);
-        assert(r.first->second == 2.5);
-
-        r = m.insert(M::value_type(1, 1.5));
-        assert(r.second);
-        assert(r.first == m.begin());
-        assert(m.size() == 2);
-        assert(r.first->first == 1);
-        assert(r.first->second == 1.5);
+    typedef Container M;
+    typedef std::pair<typename M::iterator, bool> R;
+    typedef typename M::value_type VT;
+    M m;
 
-        r = m.insert(M::value_type(3, 3.5));
-        assert(r.second);
-        assert(r.first == prev(m.end()));
-        assert(m.size() == 3);
-        assert(r.first->first == 3);
-        assert(r.first->second == 3.5);
+    const VT v1(2, 2.5);
+    R r = m.insert(v1);
+    assert(r.second);
+    assert(r.first == m.begin());
+    assert(m.size() == 1);
+    assert(r.first->first == 2);
+    assert(r.first->second == 2.5);
 
-        r = m.insert(M::value_type(3, 3.5));
-        assert(!r.second);
-        assert(r.first == prev(m.end()));
-        assert(m.size() == 3);
-        assert(r.first->first == 3);
-        assert(r.first->second == 3.5);
-    }
-#if __cplusplus >= 201103L
-    {
-        typedef std::map<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
-        typedef std::pair<M::iterator, bool> R;
-        M m;
-        R r = m.insert(M::value_type(2, 2.5));
-        assert(r.second);
-        assert(r.first == m.begin());
-        assert(m.size() == 1);
-        assert(r.first->first == 2);
-        assert(r.first->second == 2.5);
+    const VT v2(1, 1.5);
+    r = m.insert(v2);
+    assert(r.second);
+    assert(r.first == m.begin());
+    assert(m.size() == 2);
+    assert(r.first->first == 1);
+    assert(r.first->second == 1.5);
 
-        r = m.insert(M::value_type(1, 1.5));
-        assert(r.second);
-        assert(r.first == m.begin());
-        assert(m.size() == 2);
-        assert(r.first->first == 1);
-        assert(r.first->second == 1.5);
+    const VT v3(3, 3.5);
+    r = m.insert(v3);
+    assert(r.second);
+    assert(r.first == prev(m.end()));
+    assert(m.size() == 3);
+    assert(r.first->first == 3);
+    assert(r.first->second == 3.5);
 
-        r = m.insert(M::value_type(3, 3.5));
-        assert(r.second);
-        assert(r.first == prev(m.end()));
-        assert(m.size() == 3);
-        assert(r.first->first == 3);
-        assert(r.first->second == 3.5);
+    const VT v4(3, 4.5);
+    r = m.insert(v4);
+    assert(!r.second);
+    assert(r.first == prev(m.end()));
+    assert(m.size() == 3);
+    assert(r.first->first == 3);
+    assert(r.first->second == 3.5);
+}
 
-        r = m.insert(M::value_type(3, 3.5));
-        assert(!r.second);
-        assert(r.first == prev(m.end()));
-        assert(m.size() == 3);
-        assert(r.first->first == 3);
-        assert(r.first->second == 3.5);
+int main()
+{
+    do_insert_cv_test<std::map<int, double> >();
+#if TEST_STD_VER >= 11
+    {
+        typedef std::map<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
+        do_insert_cv_test<M>();
     }
 #endif
 }
diff --git a/test/std/containers/associative/map/map.modifiers/insert_initializer_list.pass.cpp b/test/std/containers/associative/map/map.modifiers/insert_initializer_list.pass.cpp
index ab325ed45bfc..9cf3f3dcf74f 100644
--- a/test/std/containers/associative/map/map.modifiers/insert_initializer_list.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/insert_initializer_list.pass.cpp
@@ -43,7 +43,7 @@ int main()
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::pair<const int, double> V;
     std::map<int, double, std::less<int>, min_allocator<V>> m =
diff --git a/test/std/containers/associative/map/map.modifiers/insert_iter_cv.pass.cpp b/test/std/containers/associative/map/map.modifiers/insert_iter_cv.pass.cpp
index 278db4631a8c..0c7e124e0d1c 100644
--- a/test/std/containers/associative/map/map.modifiers/insert_iter_cv.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/insert_iter_cv.pass.cpp
@@ -16,66 +16,53 @@
 #include <map>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+template <class Container>
+void do_insert_iter_cv_test()
 {
-    {
-        typedef std::map<int, double> M;
-        typedef M::iterator R;
-        M m;
-        R r = m.insert(m.end(), M::value_type(2, 2.5));
-        assert(r == m.begin());
-        assert(m.size() == 1);
-        assert(r->first == 2);
-        assert(r->second == 2.5);
-
-        r = m.insert(m.end(), M::value_type(1, 1.5));
-        assert(r == m.begin());
-        assert(m.size() == 2);
-        assert(r->first == 1);
-        assert(r->second == 1.5);
+    typedef Container M;
+    typedef typename M::iterator R;
+    typedef typename M::value_type VT;
 
-        r = m.insert(m.end(), M::value_type(3, 3.5));
-        assert(r == prev(m.end()));
-        assert(m.size() == 3);
-        assert(r->first == 3);
-        assert(r->second == 3.5);
+    M m;
+    const VT v1(2, 2.5);
+    R r = m.insert(m.end(), v1);
+    assert(r == m.begin());
+    assert(m.size() == 1);
+    assert(r->first == 2);
+    assert(r->second == 2.5);
 
-        r = m.insert(m.end(), M::value_type(3, 3.5));
-        assert(r == prev(m.end()));
-        assert(m.size() == 3);
-        assert(r->first == 3);
-        assert(r->second == 3.5);
-    }
-#if __cplusplus >= 201103L
-    {
-        typedef std::map<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
-        typedef M::iterator R;
-        M m;
-        R r = m.insert(m.end(), M::value_type(2, 2.5));
-        assert(r == m.begin());
-        assert(m.size() == 1);
-        assert(r->first == 2);
-        assert(r->second == 2.5);
+    const VT v2(1, 1.5);
+    r = m.insert(m.end(), v2);
+    assert(r == m.begin());
+    assert(m.size() == 2);
+    assert(r->first == 1);
+    assert(r->second == 1.5);
 
-        r = m.insert(m.end(), M::value_type(1, 1.5));
-        assert(r == m.begin());
-        assert(m.size() == 2);
-        assert(r->first == 1);
-        assert(r->second == 1.5);
+    const VT v3(3, 3.5);
+    r = m.insert(m.end(), v3);
+    assert(r == prev(m.end()));
+    assert(m.size() == 3);
+    assert(r->first == 3);
+    assert(r->second == 3.5);
 
-        r = m.insert(m.end(), M::value_type(3, 3.5));
-        assert(r == prev(m.end()));
-        assert(m.size() == 3);
-        assert(r->first == 3);
-        assert(r->second == 3.5);
+    const VT v4(3, 4.5);
+    r = m.insert(m.end(), v4);
+    assert(r == prev(m.end()));
+    assert(m.size() == 3);
+    assert(r->first == 3);
+    assert(r->second == 3.5);
+}
 
-        r = m.insert(m.end(), M::value_type(3, 3.5));
-        assert(r == prev(m.end()));
-        assert(m.size() == 3);
-        assert(r->first == 3);
-        assert(r->second == 3.5);
+int main()
+{
+    do_insert_iter_cv_test<std::map<int, double> >();
+#if TEST_STD_VER >= 11
+    {
+        typedef std::map<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
+        do_insert_iter_cv_test<M>();
     }
 #endif
 }
diff --git a/test/std/containers/associative/map/map.modifiers/insert_iter_iter.pass.cpp b/test/std/containers/associative/map/map.modifiers/insert_iter_iter.pass.cpp
index 964738b4a68a..edc1a1e2c62b 100644
--- a/test/std/containers/associative/map/map.modifiers/insert_iter_iter.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/insert_iter_iter.pass.cpp
@@ -47,7 +47,7 @@ int main()
         assert(next(m.begin(), 2)->first == 3);
         assert(next(m.begin(), 2)->second == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::map<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
         typedef std::pair<int, double> P;
diff --git a/test/std/containers/associative/map/map.modifiers/insert_iter_rv.pass.cpp b/test/std/containers/associative/map/map.modifiers/insert_iter_rv.pass.cpp
index 9db1e5c70732..3edb9c06e7c0 100644
--- a/test/std/containers/associative/map/map.modifiers/insert_iter_rv.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/insert_iter_rv.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <map>
 
 // class map
@@ -21,70 +23,49 @@
 #include "min_allocator.h"
 #include "test_macros.h"
 
-int main()
+template <class Container, class Pair>
+void do_insert_iter_rv_test()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    {
-        typedef std::map<int, MoveOnly> M;
-        typedef std::pair<int, MoveOnly> P;
-        typedef M::iterator R;
-        M m;
-        R r = m.insert(m.end(), P(2, 2));
-        assert(r == m.begin());
-        assert(m.size() == 1);
-        assert(r->first == 2);
-        assert(r->second == 2);
+    typedef Container M;
+    typedef Pair P;
+    typedef typename M::iterator R;
+    M m;
+    R r = m.insert(m.end(), P(2, 2));
+    assert(r == m.begin());
+    assert(m.size() == 1);
+    assert(r->first == 2);
+    assert(r->second == 2);
 
-        r = m.insert(m.end(), P(1, 1));
-        assert(r == m.begin());
-        assert(m.size() == 2);
-        assert(r->first == 1);
-        assert(r->second == 1);
+    r = m.insert(m.end(), P(1, 1));
+    assert(r == m.begin());
+    assert(m.size() == 2);
+    assert(r->first == 1);
+    assert(r->second == 1);
 
-        r = m.insert(m.end(), P(3, 3));
-        assert(r == prev(m.end()));
-        assert(m.size() == 3);
-        assert(r->first == 3);
-        assert(r->second == 3);
+    r = m.insert(m.end(), P(3, 3));
+    assert(r == prev(m.end()));
+    assert(m.size() == 3);
+    assert(r->first == 3);
+    assert(r->second == 3);
+
+    r = m.insert(m.end(), P(3, 4));
+    assert(r == prev(m.end()));
+    assert(m.size() == 3);
+    assert(r->first == 3);
+    assert(r->second == 3);
+}
+int main()
+{
+    do_insert_iter_rv_test<std::map<int, MoveOnly>, std::pair<int, MoveOnly>>();
+    do_insert_iter_rv_test<std::map<int, MoveOnly>, std::pair<const int, MoveOnly>>();
 
-        r = m.insert(m.end(), P(3, 3));
-        assert(r == prev(m.end()));
-        assert(m.size() == 3);
-        assert(r->first == 3);
-        assert(r->second == 3);
-    }
-#if TEST_STD_VER >= 11
     {
         typedef std::map<int, MoveOnly, std::less<int>, min_allocator<std::pair<const int, MoveOnly>>> M;
         typedef std::pair<int, MoveOnly> P;
-        typedef M::iterator R;
-        M m;
-        R r = m.insert(m.end(), P(2, 2));
-        assert(r == m.begin());
-        assert(m.size() == 1);
-        assert(r->first == 2);
-        assert(r->second == 2);
-
-        r = m.insert(m.end(), P(1, 1));
-        assert(r == m.begin());
-        assert(m.size() == 2);
-        assert(r->first == 1);
-        assert(r->second == 1);
-
-        r = m.insert(m.end(), P(3, 3));
-        assert(r == prev(m.end()));
-        assert(m.size() == 3);
-        assert(r->first == 3);
-        assert(r->second == 3);
-
-        r = m.insert(m.end(), P(3, 3));
-        assert(r == prev(m.end()));
-        assert(m.size() == 3);
-        assert(r->first == 3);
-        assert(r->second == 3);
+        typedef std::pair<const int, MoveOnly> CP;
+        do_insert_iter_rv_test<M, P>();
+        do_insert_iter_rv_test<M, CP>();
     }
-#endif
-#if TEST_STD_VER > 14
     {
         typedef std::map<int, MoveOnly> M;
         typedef M::iterator R;
@@ -113,6 +94,5 @@ int main()
         assert(r->first == 3);
         assert(r->second == 3);
     }
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#endif
+
 }
diff --git a/test/std/containers/associative/map/map.modifiers/insert_or_assign.pass.cpp b/test/std/containers/associative/map/map.modifiers/insert_or_assign.pass.cpp
index 484ed06247d1..8689dc7284d5 100644
--- a/test/std/containers/associative/map/map.modifiers/insert_or_assign.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/insert_or_assign.pass.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// UNSUPPORTED: c++03, c++11, c++14
+// UNSUPPORTED: c++98, c++03, c++11, c++14
 
 // <map>
 
@@ -22,7 +22,6 @@
 // template <class M>
 //  iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);        // C++17
 
-#include <__config>
 #include <map>
 #include <cassert>
 #include <tuple>
@@ -60,9 +59,6 @@ public:
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#ifndef _LIBCPP_HAS_NO_VARIADICS
-
     { // pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
         typedef std::map<int, Moveable> M;
         typedef std::pair<M::iterator, bool> R;
@@ -186,7 +182,4 @@ int main()
         assert(r->first.get()  == 3);  // key
         assert(r->second.get() == 5);  // value
     }
-
-#endif  // _LIBCPP_HAS_NO_VARIADICS
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-}
\ No newline at end of file
+}
diff --git a/test/std/containers/associative/map/map.modifiers/insert_rv.pass.cpp b/test/std/containers/associative/map/map.modifiers/insert_rv.pass.cpp
index 23eb84d687ff..503d9291076d 100644
--- a/test/std/containers/associative/map/map.modifiers/insert_rv.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/insert_rv.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <map>
 
 // class map
@@ -22,76 +24,54 @@
 #include "min_allocator.h"
 #include "test_macros.h"
 
-int main()
+template <class Container, class Pair>
+void do_insert_rv_test()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    {
-        typedef std::map<int, MoveOnly> M;
-        typedef std::pair<M::iterator, bool> R;
-        M m;
-        R r = m.insert(M::value_type(2, 2));
-        assert(r.second);
-        assert(r.first == m.begin());
-        assert(m.size() == 1);
-        assert(r.first->first == 2);
-        assert(r.first->second == 2);
+    typedef Container M;
+    typedef Pair P;
+    typedef std::pair<typename M::iterator, bool> R;
+    M m;
+    R r = m.insert(P(2, 2));
+    assert(r.second);
+    assert(r.first == m.begin());
+    assert(m.size() == 1);
+    assert(r.first->first == 2);
+    assert(r.first->second == 2);
 
-        r = m.insert(M::value_type(1, 1));
-        assert(r.second);
-        assert(r.first == m.begin());
-        assert(m.size() == 2);
-        assert(r.first->first == 1);
-        assert(r.first->second == 1);
+    r = m.insert(P(1, 1));
+    assert(r.second);
+    assert(r.first == m.begin());
+    assert(m.size() == 2);
+    assert(r.first->first == 1);
+    assert(r.first->second == 1);
 
-        r = m.insert(M::value_type(3, 3));
-        assert(r.second);
-        assert(r.first == prev(m.end()));
-        assert(m.size() == 3);
-        assert(r.first->first == 3);
-        assert(r.first->second == 3);
+    r = m.insert(P(3, 3));
+    assert(r.second);
+    assert(r.first == prev(m.end()));
+    assert(m.size() == 3);
+    assert(r.first->first == 3);
+    assert(r.first->second == 3);
 
-        r = m.insert(M::value_type(3, 3));
-        assert(!r.second);
-        assert(r.first == prev(m.end()));
-        assert(m.size() == 3);
-        assert(r.first->first == 3);
-        assert(r.first->second == 3);
-    }
-#if TEST_STD_VER >= 11
-    {
-        typedef std::map<int, MoveOnly, std::less<int>, min_allocator<std::pair<const int, MoveOnly>>> M;
-        typedef std::pair<M::iterator, bool> R;
-        M m;
-        R r = m.insert(M::value_type(2, 2));
-        assert(r.second);
-        assert(r.first == m.begin());
-        assert(m.size() == 1);
-        assert(r.first->first == 2);
-        assert(r.first->second == 2);
-
-        r = m.insert(M::value_type(1, 1));
-        assert(r.second);
-        assert(r.first == m.begin());
-        assert(m.size() == 2);
-        assert(r.first->first == 1);
-        assert(r.first->second == 1);
+    r = m.insert(P(3, 3));
+    assert(!r.second);
+    assert(r.first == prev(m.end()));
+    assert(m.size() == 3);
+    assert(r.first->first == 3);
+    assert(r.first->second == 3);
+}
 
-        r = m.insert(M::value_type(3, 3));
-        assert(r.second);
-        assert(r.first == prev(m.end()));
-        assert(m.size() == 3);
-        assert(r.first->first == 3);
-        assert(r.first->second == 3);
+int main()
+{
+    do_insert_rv_test<std::map<int, MoveOnly>, std::pair<int, MoveOnly>>();
+    do_insert_rv_test<std::map<int, MoveOnly>, std::pair<const int, MoveOnly>>();
 
-        r = m.insert(M::value_type(3, 3));
-        assert(!r.second);
-        assert(r.first == prev(m.end()));
-        assert(m.size() == 3);
-        assert(r.first->first == 3);
-        assert(r.first->second == 3);
+    {
+        typedef std::map<int, MoveOnly, std::less<int>, min_allocator<std::pair<const int, MoveOnly>>> M;
+        typedef std::pair<int, MoveOnly> P;
+        typedef std::pair<const int, MoveOnly> CP;
+        do_insert_rv_test<M, P>();
+        do_insert_rv_test<M, CP>();
     }
-#endif
-#if TEST_STD_VER > 14
     {
         typedef std::map<int, MoveOnly> M;
         typedef std::pair<M::iterator, bool> R;
@@ -124,6 +104,4 @@ int main()
         assert(r.first->first == 3);
         assert(r.first->second == 3);
     }
-#endif
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/containers/associative/map/map.modifiers/try.emplace.pass.cpp b/test/std/containers/associative/map/map.modifiers/try.emplace.pass.cpp
index 8e0dd7577bbd..63704c91440e 100644
--- a/test/std/containers/associative/map/map.modifiers/try.emplace.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/try.emplace.pass.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// UNSUPPORTED: c++03, c++11, c++14
+// UNSUPPORTED: c++98, c++03, c++11, c++14
 
 // <map>
 
@@ -22,7 +22,6 @@
 // template <class... Args>
 //  iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);      // C++17
 
-#include <__config>
 #include <map>
 #include <cassert>
 #include <tuple>
@@ -58,9 +57,6 @@ public:
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#ifndef _LIBCPP_HAS_NO_VARIADICS
-
     { // pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
         typedef std::map<int, Moveable> M;
         typedef std::pair<M::iterator, bool> R;
@@ -104,7 +100,7 @@ int main()
         assert(r.first->second.get() == -1); // value
     }
 
-    {  // pair<iterator, bool> try_emplace(key_type&& k, Args&&... args); 
+    {  // pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
         typedef std::map<Moveable, Moveable> M;
         typedef std::pair<M::iterator, bool> R;
         M m;
@@ -140,7 +136,7 @@ int main()
             m.try_emplace ( i, Moveable(i, (double) i));
         assert(m.size() == 10);
         M::const_iterator it = m.find(2);
-        
+
         Moveable mv1(3, 3.0);
         for (int i=0; i < 20; i += 2)
         {
@@ -183,7 +179,4 @@ int main()
         assert(r->first.get()  == 3); // key
         assert(r->second.get() == 4); // value
     }
-
-#endif  // _LIBCPP_HAS_NO_VARIADICS
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/containers/associative/map/map.ops/count.pass.cpp b/test/std/containers/associative/map/map.ops/count.pass.cpp
index ae87ae8345e9..f3df31951c79 100644
--- a/test/std/containers/associative/map/map.ops/count.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/count.pass.cpp
@@ -59,7 +59,7 @@ int main()
         assert(r == 0);
     }
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::pair<const int, double> V;
     typedef std::map<int, double, std::less<int>, min_allocator<V>> M;
diff --git a/test/std/containers/associative/map/map.ops/count0.pass.cpp b/test/std/containers/associative/map/map.ops/count0.pass.cpp
index ce549366e7ab..0278343006a8 100644
--- a/test/std/containers/associative/map/map.ops/count0.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/count0.pass.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// XFAIL: c++03, c++11
+// XFAIL: c++98, c++03, c++11
 
 // <map>
 
@@ -15,9 +15,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/map/map.ops/count1.fail.cpp b/test/std/containers/associative/map/map.ops/count1.fail.cpp
index 9c15059d490e..075a5ba2e0ab 100644
--- a/test/std/containers/associative/map/map.ops/count1.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/count1.fail.cpp
@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/map/map.ops/count2.fail.cpp b/test/std/containers/associative/map/map.ops/count2.fail.cpp
index 7aa1553ef47a..de1899021805 100644
--- a/test/std/containers/associative/map/map.ops/count2.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/count2.fail.cpp
@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/map/map.ops/count3.fail.cpp b/test/std/containers/associative/map/map.ops/count3.fail.cpp
index 7e7bb8f6d370..b139689fec74 100644
--- a/test/std/containers/associative/map/map.ops/count3.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/count3.fail.cpp
@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/map/map.ops/equal_range.pass.cpp b/test/std/containers/associative/map/map.ops/equal_range.pass.cpp
index a71149a47212..8beeb8b30f58 100644
--- a/test/std/containers/associative/map/map.ops/equal_range.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/equal_range.pass.cpp
@@ -159,7 +159,7 @@ int main()
         assert(r.second == next(m.begin(), 8));
     }
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::pair<const int, double> V;
     typedef std::map<int, double, std::less<int>, min_allocator<V>> M;
diff --git a/test/std/containers/associative/map/map.ops/equal_range0.pass.cpp b/test/std/containers/associative/map/map.ops/equal_range0.pass.cpp
index c95c3dffa9a5..3b98426868e4 100644
--- a/test/std/containers/associative/map/map.ops/equal_range0.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/equal_range0.pass.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// XFAIL: c++03, c++11
+// XFAIL: c++98, c++03, c++11
 
 // <map>
 
@@ -15,9 +15,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/map/map.ops/equal_range1.fail.cpp b/test/std/containers/associative/map/map.ops/equal_range1.fail.cpp
index 8f0da08eb322..c66c2c512142 100644
--- a/test/std/containers/associative/map/map.ops/equal_range1.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/equal_range1.fail.cpp
@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/map/map.ops/equal_range2.fail.cpp b/test/std/containers/associative/map/map.ops/equal_range2.fail.cpp
index e73122d6533b..85083d4f4796 100644
--- a/test/std/containers/associative/map/map.ops/equal_range2.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/equal_range2.fail.cpp
@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/map/map.ops/equal_range3.fail.cpp b/test/std/containers/associative/map/map.ops/equal_range3.fail.cpp
index bb72e9e7a6d4..c9f1126e5baf 100644
--- a/test/std/containers/associative/map/map.ops/equal_range3.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/equal_range3.fail.cpp
@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/map/map.ops/find.pass.cpp b/test/std/containers/associative/map/map.ops/find.pass.cpp
index 17463b65740f..225f0f406042 100644
--- a/test/std/containers/associative/map/map.ops/find.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/find.pass.cpp
@@ -93,7 +93,7 @@ int main()
         assert(r == next(m.begin(), 8));
     }
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::pair<const int, double> V;
     typedef std::map<int, double, std::less<int>, min_allocator<V>> M;
diff --git a/test/std/containers/associative/map/map.ops/find0.pass.cpp b/test/std/containers/associative/map/map.ops/find0.pass.cpp
index 5f310b07c599..d7de579d8b44 100644
--- a/test/std/containers/associative/map/map.ops/find0.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/find0.pass.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// XFAIL: c++03, c++11
+// XFAIL: c++98, c++03, c++11
 
 // <map>
 
@@ -15,9 +15,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/map/map.ops/find1.fail.cpp b/test/std/containers/associative/map/map.ops/find1.fail.cpp
index c33b5a9a34cf..4fe61117613c 100644
--- a/test/std/containers/associative/map/map.ops/find1.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/find1.fail.cpp
@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/map/map.ops/find2.fail.cpp b/test/std/containers/associative/map/map.ops/find2.fail.cpp
index 40bf323a4538..3532dc8765b3 100644
--- a/test/std/containers/associative/map/map.ops/find2.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/find2.fail.cpp
@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/map/map.ops/find3.fail.cpp b/test/std/containers/associative/map/map.ops/find3.fail.cpp
index 9526c0e24d9e..be77330a29c8 100644
--- a/test/std/containers/associative/map/map.ops/find3.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/find3.fail.cpp
@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/map/map.ops/lower_bound.pass.cpp b/test/std/containers/associative/map/map.ops/lower_bound.pass.cpp
index 3cbfbf7d869f..e4359fa548b9 100644
--- a/test/std/containers/associative/map/map.ops/lower_bound.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/lower_bound.pass.cpp
@@ -125,7 +125,7 @@ int main()
         assert(r == next(m.begin(), 8));
     }
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::pair<const int, double> V;
     typedef std::map<int, double, std::less<int>, min_allocator<V>> M;
@@ -317,7 +317,7 @@ int main()
     r = m.lower_bound(C2Int(20));
     assert(r == next(m.begin(), 8));
     }
-    
+
     {
     typedef PrivateConstructor PC;
     typedef std::map<PC, double, std::less<>> M;
diff --git a/test/std/containers/associative/map/map.ops/lower_bound0.pass.cpp b/test/std/containers/associative/map/map.ops/lower_bound0.pass.cpp
index 2fc095a8f2c1..ea121df73002 100644
--- a/test/std/containers/associative/map/map.ops/lower_bound0.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/lower_bound0.pass.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// XFAIL: c++03, c++11
+// XFAIL: c++98, c++03, c++11
 
 // <map>
 
@@ -15,9 +15,9 @@
 
 //       iterator lower_bound(const key_type& k);
 // const_iterator lower_bound(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/map/map.ops/lower_bound1.fail.cpp b/test/std/containers/associative/map/map.ops/lower_bound1.fail.cpp
index a4a986c1a7a4..97bbf553205f 100644
--- a/test/std/containers/associative/map/map.ops/lower_bound1.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/lower_bound1.fail.cpp
@@ -13,9 +13,9 @@
 
 //       iterator lower_bound(const key_type& k);
 // const_iterator lower_bound(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/map/map.ops/lower_bound2.fail.cpp b/test/std/containers/associative/map/map.ops/lower_bound2.fail.cpp
index 3f6380e5e25f..eeae8e657387 100644
--- a/test/std/containers/associative/map/map.ops/lower_bound2.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/lower_bound2.fail.cpp
@@ -13,9 +13,9 @@
 
 //       iterator lower_bound(const key_type& k);
 // const_iterator lower_bound(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/map/map.ops/lower_bound3.fail.cpp b/test/std/containers/associative/map/map.ops/lower_bound3.fail.cpp
index 18f2c7b71fde..ba27ae3c5172 100644
--- a/test/std/containers/associative/map/map.ops/lower_bound3.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/lower_bound3.fail.cpp
@@ -13,9 +13,9 @@
 
 //       iterator lower_bound(const key_type& k);
 // const_iterator lower_bound(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/map/map.ops/upper_bound.pass.cpp b/test/std/containers/associative/map/map.ops/upper_bound.pass.cpp
index 037ceb962cd8..8c721947a2c3 100644
--- a/test/std/containers/associative/map/map.ops/upper_bound.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/upper_bound.pass.cpp
@@ -124,7 +124,7 @@ int main()
         assert(r == next(m.begin(), 8));
     }
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::pair<const int, double> V;
     typedef std::map<int, double, std::less<int>, min_allocator<V>> M;
@@ -280,7 +280,7 @@ int main()
     r = m.upper_bound(20);
     assert(r == next(m.begin(), 8));
     }
-    
+
     {
     typedef PrivateConstructor PC;
     typedef std::map<PC, double, std::less<>> M;
diff --git a/test/std/containers/associative/map/map.ops/upper_bound0.pass.cpp b/test/std/containers/associative/map/map.ops/upper_bound0.pass.cpp
index c58e55f29793..2e597b85cf0c 100644
--- a/test/std/containers/associative/map/map.ops/upper_bound0.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/upper_bound0.pass.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// XFAIL: c++03, c++11
+// XFAIL: c++98, c++03, c++11
 
 // <map>
 
@@ -15,9 +15,9 @@
 
 //       iterator upper_bound(const key_type& k);
 // const_iterator upper_bound(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/map/map.ops/upper_bound1.fail.cpp b/test/std/containers/associative/map/map.ops/upper_bound1.fail.cpp
index 4647681b5cd1..6568e04bfad4 100644
--- a/test/std/containers/associative/map/map.ops/upper_bound1.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/upper_bound1.fail.cpp
@@ -13,9 +13,9 @@
 
 //       iterator upper_bound(const key_type& k);
 // const_iterator upper_bound(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/map/map.ops/upper_bound2.fail.cpp b/test/std/containers/associative/map/map.ops/upper_bound2.fail.cpp
index 11852fe0cc9f..bbb857e6f25a 100644
--- a/test/std/containers/associative/map/map.ops/upper_bound2.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/upper_bound2.fail.cpp
@@ -13,9 +13,9 @@
 
 //       iterator upper_bound(const key_type& k);
 // const_iterator upper_bound(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/map/map.ops/upper_bound3.fail.cpp b/test/std/containers/associative/map/map.ops/upper_bound3.fail.cpp
index 9cddeb8acbdc..ed9a41e4f03f 100644
--- a/test/std/containers/associative/map/map.ops/upper_bound3.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/upper_bound3.fail.cpp
@@ -13,9 +13,9 @@
 
 //       iterator upper_bound(const key_type& k);
 // const_iterator upper_bound(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/map/map.special/member_swap.pass.cpp b/test/std/containers/associative/map/map.special/member_swap.pass.cpp
index 7c3ad9d50ae4..f0913a77c2eb 100644
--- a/test/std/containers/associative/map/map.special/member_swap.pass.cpp
+++ b/test/std/containers/associative/map/map.special/member_swap.pass.cpp
@@ -96,7 +96,7 @@ int main()
         assert(m2 == m1_save);
     }
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::map<int, double, std::less<int>, min_allocator<V>> M;
     {
diff --git a/test/std/containers/associative/map/map.special/non_member_swap.pass.cpp b/test/std/containers/associative/map/map.special/non_member_swap.pass.cpp
index b042a4878f8a..103a57b17e07 100644
--- a/test/std/containers/associative/map/map.special/non_member_swap.pass.cpp
+++ b/test/std/containers/associative/map/map.special/non_member_swap.pass.cpp
@@ -98,6 +98,7 @@ int main()
         assert(m1 == m2_save);
         assert(m2 == m1_save);
     }
+    }
     {
         typedef test_allocator<V> A;
         typedef test_compare<std::less<int> > C;
@@ -166,8 +167,7 @@ int main()
         assert(m2.key_comp() == C(1));
         assert(m2.get_allocator() == A(1));
     }
-    }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::map<int, double, std::less<int>, min_allocator<V>> M;
     {
@@ -242,6 +242,7 @@ int main()
         assert(m1 == m2_save);
         assert(m2 == m1_save);
     }
+    }
     {
         typedef min_allocator<V> A;
         typedef test_compare<std::less<int> > C;
@@ -276,6 +277,5 @@ int main()
         assert(m2.key_comp() == C(1));
         assert(m2.get_allocator() == A());
     }
-    }
 #endif
 }
diff --git a/test/std/containers/associative/map/map.special/swap_noexcept.pass.cpp b/test/std/containers/associative/map/map.special/swap_noexcept.pass.cpp
index f25dff2c86da..cbbf4577ce62 100644
--- a/test/std/containers/associative/map/map.special/swap_noexcept.pass.cpp
+++ b/test/std/containers/associative/map/map.special/swap_noexcept.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <map>
 
 // void swap(map& c)
@@ -15,13 +17,14 @@
 //
 //  In C++17, the standard says that swap shall have:
 //     noexcept(allocator_traits<Allocator>::is_always_equal::value &&
-//              noexcept(swap(declval<Compare&>(), declval<Compare&>())));                 
+//              noexcept(swap(declval<Compare&>(), declval<Compare&>())));
 
 // This tests a conforming extension
 
 #include <map>
 #include <cassert>
 
+#include "test_macros.h"
 #include "MoveOnly.h"
 #include "test_allocator.h"
 
@@ -29,23 +32,20 @@ template <class T>
 struct some_comp
 {
     typedef T value_type;
-    
+
     some_comp() {}
     some_comp(const some_comp&) {}
-    void deallocate(void*, unsigned) {}
-
-    typedef std::true_type propagate_on_container_swap;
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 template <class T>
 struct some_comp2
 {
     typedef T value_type;
-    
+
     some_comp2() {}
     some_comp2(const some_comp2&) {}
-    void deallocate(void*, unsigned) {}
-    typedef std::true_type propagate_on_container_swap;
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 #if TEST_STD_VER >= 14
@@ -57,7 +57,7 @@ template <class T>
 struct some_alloc
 {
     typedef T value_type;
-    
+
     some_alloc() {}
     some_alloc(const some_alloc&);
     void deallocate(void*, unsigned) {}
@@ -69,7 +69,7 @@ template <class T>
 struct some_alloc2
 {
     typedef T value_type;
-    
+
     some_alloc2() {}
     some_alloc2(const some_alloc2&);
     void deallocate(void*, unsigned) {}
@@ -82,7 +82,7 @@ template <class T>
 struct some_alloc3
 {
     typedef T value_type;
-    
+
     some_alloc3() {}
     some_alloc3(const some_alloc3&);
     void deallocate(void*, unsigned) {}
@@ -93,7 +93,6 @@ struct some_alloc3
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     typedef std::pair<const MoveOnly, MoveOnly> V;
     {
         typedef std::map<MoveOnly, MoveOnly> C;
@@ -145,5 +144,4 @@ int main()
     }
 #endif
 
-#endif
 }
diff --git a/test/std/containers/associative/map/types.pass.cpp b/test/std/containers/associative/map/types.pass.cpp
index d117deff693d..67cd5acaae89 100644
--- a/test/std/containers/associative/map/types.pass.cpp
+++ b/test/std/containers/associative/map/types.pass.cpp
@@ -50,7 +50,7 @@ int main()
     static_assert((std::is_same<C::size_type, std::size_t>::value), "");
     static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::map<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> C;
     static_assert((std::is_same<C::key_type, int>::value), "");
diff --git a/test/std/containers/associative/multimap/empty.pass.cpp b/test/std/containers/associative/multimap/empty.pass.cpp
index 2384960d10db..f1388d8bfa5a 100644
--- a/test/std/containers/associative/multimap/empty.pass.cpp
+++ b/test/std/containers/associative/multimap/empty.pass.cpp
@@ -29,7 +29,7 @@ int main()
     m.clear();
     assert(m.empty());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
     M m;
diff --git a/test/std/containers/associative/multimap/incomplete_type.pass.cpp b/test/std/containers/associative/multimap/incomplete_type.pass.cpp
new file mode 100644
index 000000000000..c461eb38139d
--- /dev/null
+++ b/test/std/containers/associative/multimap/incomplete_type.pass.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <map>
+
+// Check that std::multimap and it's iterators can be instantiated with an incomplete
+// type.
+
+#include <map>
+
+struct A {
+    typedef std::multimap<A, A> Map;
+    int data;
+    Map m;
+    Map::iterator it;
+    Map::const_iterator cit;
+};
+
+inline bool operator==(A const& L, A const& R) { return &L == &R; }
+inline bool operator<(A const& L, A const& R)  { return L.data < R.data; }
+int main() {
+    A a;
+}
diff --git a/test/std/containers/associative/multimap/iterator.pass.cpp b/test/std/containers/associative/multimap/iterator.pass.cpp
index 2763129acc2a..ef7c5ef18af1 100644
--- a/test/std/containers/associative/multimap/iterator.pass.cpp
+++ b/test/std/containers/associative/multimap/iterator.pass.cpp
@@ -121,7 +121,7 @@ int main()
                 assert(i->second == d);
             }
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::pair<const int, double> V;
         V ar[] =
diff --git a/test/std/containers/associative/multimap/max_size.pass.cpp b/test/std/containers/associative/multimap/max_size.pass.cpp
index ccd8b10638c1..b7cf226d8f13 100644
--- a/test/std/containers/associative/multimap/max_size.pass.cpp
+++ b/test/std/containers/associative/multimap/max_size.pass.cpp
@@ -25,7 +25,7 @@ int main()
     M m;
     assert(m.max_size() != 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
     M m;
diff --git a/test/std/containers/associative/multimap/multimap.cons/alloc.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/alloc.pass.cpp
index 87bf0447e5be..69660fcd2772 100644
--- a/test/std/containers/associative/multimap/multimap.cons/alloc.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/alloc.pass.cpp
@@ -29,7 +29,7 @@ int main()
     assert(m.begin() == m.end());
     assert(m.get_allocator() == A(5));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::less<int> C;
     typedef min_allocator<std::pair<const int, double> > A;
diff --git a/test/std/containers/associative/multimap/multimap.cons/assign_initializer_list.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/assign_initializer_list.pass.cpp
index 0c8991832529..4c0326d90fe6 100644
--- a/test/std/containers/associative/multimap/multimap.cons/assign_initializer_list.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/assign_initializer_list.pass.cpp
@@ -50,7 +50,7 @@ int main()
     assert(*++i == V(3, 1.5));
     assert(*++i == V(3, 2));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> C;
     typedef C::value_type V;
diff --git a/test/std/containers/associative/multimap/multimap.cons/compare.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/compare.pass.cpp
index 9a4e0f987fd0..59a972f45687 100644
--- a/test/std/containers/associative/multimap/multimap.cons/compare.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/compare.pass.cpp
@@ -28,7 +28,7 @@ int main()
     assert(m.begin() == m.end());
     assert(m.key_comp() == C(3));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef test_compare<std::less<int> > C;
     std::multimap<int, double, C, min_allocator<std::pair<const int, double>>> m(C(3));
diff --git a/test/std/containers/associative/multimap/multimap.cons/compare_alloc.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/compare_alloc.pass.cpp
index 1224884939cf..836532892499 100644
--- a/test/std/containers/associative/multimap/multimap.cons/compare_alloc.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/compare_alloc.pass.cpp
@@ -31,7 +31,7 @@ int main()
     assert(m.key_comp() == C(4));
     assert(m.get_allocator() == A(5));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef test_compare<std::less<int> > C;
     typedef min_allocator<std::pair<const int, double> > A;
diff --git a/test/std/containers/associative/multimap/multimap.cons/compare_copy_constructible.fail.cpp b/test/std/containers/associative/multimap/multimap.cons/compare_copy_constructible.fail.cpp
new file mode 100644
index 000000000000..e6f6c3efee5b
--- /dev/null
+++ b/test/std/containers/associative/multimap/multimap.cons/compare_copy_constructible.fail.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <map>
+
+// Check that std::multimap fails to instantiate if the comparison predicate is 
+// not copy-constructible. This is LWG issue 2436
+
+#include <map>
+
+template <class T>
+struct Comp {
+	bool operator () (const T& lhs, const T& rhs) const { return lhs < rhs; }
+
+	Comp () {}
+private:
+	Comp (const Comp &); // declared but not defined
+	};
+
+
+int main() {
+	std::multimap<int, int, Comp<int> > m;
+}
diff --git a/test/std/containers/associative/multimap/multimap.cons/copy.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/copy.pass.cpp
index 3d6626eaadbb..97dcf39e10c9 100644
--- a/test/std/containers/associative/multimap/multimap.cons/copy.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/copy.pass.cpp
@@ -74,7 +74,7 @@ int main()
         assert(mo.key_comp() == C(5));
     }
 #endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::pair<const int, double> V;
         V ar[] =
diff --git a/test/std/containers/associative/multimap/multimap.cons/copy_alloc.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/copy_alloc.pass.cpp
index 22594e32d718..46b9459cad28 100644
--- a/test/std/containers/associative/multimap/multimap.cons/copy_alloc.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/copy_alloc.pass.cpp
@@ -47,7 +47,7 @@ int main()
     assert(mo.get_allocator() == A(7));
     assert(mo.key_comp() == C(5));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::pair<const int, double> V;
     V ar[] =
diff --git a/test/std/containers/associative/multimap/multimap.cons/copy_assign.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/copy_assign.pass.cpp
index 2bdc4d6a70ab..b0bf8cc135f2 100644
--- a/test/std/containers/associative/multimap/multimap.cons/copy_assign.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/copy_assign.pass.cpp
@@ -94,7 +94,7 @@ int main()
         assert(mo.get_allocator() == A(2));
         assert(mo.key_comp() == C(5));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::pair<const int, double> V;
         V ar[] =
diff --git a/test/std/containers/associative/multimap/multimap.cons/default.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/default.pass.cpp
index 1c3ab8ce6c4b..d39cc1d0ee8a 100644
--- a/test/std/containers/associative/multimap/multimap.cons/default.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/default.pass.cpp
@@ -25,7 +25,7 @@ int main()
     assert(m.empty());
     assert(m.begin() == m.end());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> m;
     assert(m.empty());
diff --git a/test/std/containers/associative/multimap/multimap.cons/default_noexcept.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/default_noexcept.pass.cpp
index 5f05a0dca28e..6f97a5f3e756 100644
--- a/test/std/containers/associative/multimap/multimap.cons/default_noexcept.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/default_noexcept.pass.cpp
@@ -17,9 +17,12 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <map>
 #include <cassert>
 
+#include "test_macros.h"
 #include "MoveOnly.h"
 #include "test_allocator.h"
 
@@ -28,19 +31,19 @@ struct some_comp
 {
     typedef T value_type;
     some_comp();
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     typedef std::pair<const MoveOnly, MoveOnly> V;
     {
         typedef std::multimap<MoveOnly, MoveOnly> C;
-        static_assert(std::is_nothrow_default_constructible<C>::value, "");
+        LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
     }
     {
         typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<V>> C;
-        static_assert(std::is_nothrow_default_constructible<C>::value, "");
+        LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
     }
     {
         typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<V>> C;
@@ -50,5 +53,4 @@ int main()
         typedef std::multimap<MoveOnly, MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/associative/multimap/multimap.cons/dtor_noexcept.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/dtor_noexcept.pass.cpp
index dd1701240c63..3a240cd48af3 100644
--- a/test/std/containers/associative/multimap/multimap.cons/dtor_noexcept.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/dtor_noexcept.pass.cpp
@@ -11,26 +11,24 @@
 
 // ~multimap() // implied noexcept;
 
+// UNSUPPORTED: c++98, c++03
+
 #include <map>
 #include <cassert>
 
 #include "MoveOnly.h"
 #include "test_allocator.h"
 
-#if __has_feature(cxx_noexcept)
-
 template <class T>
 struct some_comp
 {
     typedef T value_type;
     ~some_comp() noexcept(false);
+    bool operator()(const T&, const T&) const { return false; }
 };
 
-#endif
-
 int main()
 {
-#if __has_feature(cxx_noexcept)
     typedef std::pair<const MoveOnly, MoveOnly> V;
     {
         typedef std::multimap<MoveOnly, MoveOnly> C;
@@ -48,5 +46,4 @@ int main()
         typedef std::multimap<MoveOnly, MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/associative/multimap/multimap.cons/initializer_list.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/initializer_list.pass.cpp
index 937a202a55ea..6f645b63b44c 100644
--- a/test/std/containers/associative/multimap/multimap.cons/initializer_list.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/initializer_list.pass.cpp
@@ -49,7 +49,7 @@ int main()
     assert(*++i == V(3, 1.5));
     assert(*++i == V(3, 2));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> C;
     typedef C::value_type V;
diff --git a/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare.pass.cpp
index e6677039c90c..6d20d14f4200 100644
--- a/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare.pass.cpp
@@ -53,7 +53,7 @@ int main()
     assert(*++i == V(3, 2));
     assert(m.key_comp() == Cmp(4));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef test_compare<std::less<int> > Cmp;
     typedef std::multimap<int, double, Cmp, min_allocator<std::pair<const int, double>>> C;
diff --git a/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare_alloc.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare_alloc.pass.cpp
index 0e73f72793e5..f5d3463aec42 100644
--- a/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare_alloc.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare_alloc.pass.cpp
@@ -57,7 +57,7 @@ int main()
     assert(m.get_allocator() == A(5));
     }
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef test_compare<std::less<int> > Cmp;
     typedef min_allocator<std::pair<const int, double> > A;
diff --git a/test/std/containers/associative/multimap/multimap.cons/iter_iter.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/iter_iter.pass.cpp
index fa062e2be0b8..46c56aa0b3ff 100644
--- a/test/std/containers/associative/multimap/multimap.cons/iter_iter.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/iter_iter.pass.cpp
@@ -48,7 +48,7 @@ int main()
     assert(*next(m.begin(), 7) == V(3, 1.5));
     assert(*next(m.begin(), 8) == V(3, 2));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::pair<const int, double> V;
     V ar[] =
diff --git a/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp.pass.cpp
index d6de59428dd6..614b3ed8a754 100644
--- a/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp.pass.cpp
@@ -52,7 +52,7 @@ int main()
     assert(*next(m.begin(), 7) == V(3, 1.5));
     assert(*next(m.begin(), 8) == V(3, 2));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::pair<const int, double> V;
     V ar[] =
diff --git a/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp_alloc.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp_alloc.pass.cpp
index 259fbd145ff6..31bf72dac96f 100644
--- a/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp_alloc.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp_alloc.pass.cpp
@@ -55,7 +55,7 @@ int main()
     assert(*next(m.begin(), 7) == V(3, 1.5));
     assert(*next(m.begin(), 8) == V(3, 2));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::pair<const int, double> V;
     V ar[] =
diff --git a/test/std/containers/associative/multimap/multimap.cons/move.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/move.pass.cpp
index aed08867c3cc..7edec77365d8 100644
--- a/test/std/containers/associative/multimap/multimap.cons/move.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/move.pass.cpp
@@ -75,7 +75,7 @@ int main()
         assert(mo.size() == 0);
         assert(distance(mo.begin(), mo.end()) == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef test_compare<std::less<int> > C;
         typedef min_allocator<V> A;
diff --git a/test/std/containers/associative/multimap/multimap.cons/move_alloc.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/move_alloc.pass.cpp
index 3ec79eea3554..41771f62aaea 100644
--- a/test/std/containers/associative/multimap/multimap.cons/move_alloc.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/move_alloc.pass.cpp
@@ -169,7 +169,7 @@ int main()
 
             M m1(I(a1), I(a1+num), C(), A());
             assert(Counter_base::gConstructed == 2*num);
-        
+
             M m2(m1);
             assert(m2 == m1);
             assert(Counter_base::gConstructed == 3*num);
@@ -187,9 +187,9 @@ int main()
             }
             assert(Counter_base::gConstructed == 2*num);
         }
-        assert(Counter_base::gConstructed == 0);            
+        assert(Counter_base::gConstructed == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
         typedef std::pair<const MoveOnly, MoveOnly> VC;
diff --git a/test/std/containers/associative/multimap/multimap.cons/move_assign.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/move_assign.pass.cpp
index 48854e388e10..924e9ddf1936 100644
--- a/test/std/containers/associative/multimap/multimap.cons/move_assign.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/move_assign.pass.cpp
@@ -144,7 +144,7 @@ int main()
         assert(m3.key_comp() == C(5));
         assert(m1.empty());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
         typedef std::pair<const MoveOnly, MoveOnly> VC;
diff --git a/test/std/containers/associative/multimap/multimap.cons/move_assign_noexcept.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/move_assign_noexcept.pass.cpp
index 635a8dca0357..890cac867f9e 100644
--- a/test/std/containers/associative/multimap/multimap.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/move_assign_noexcept.pass.cpp
@@ -17,6 +17,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <map>
 #include <cassert>
 
@@ -28,11 +30,11 @@ struct some_comp
 {
     typedef T value_type;
     some_comp& operator=(const some_comp&);
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     typedef std::pair<const MoveOnly, MoveOnly> V;
     {
         typedef std::multimap<MoveOnly, MoveOnly> C;
@@ -50,5 +52,4 @@ int main()
         typedef std::multimap<MoveOnly, MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/associative/multimap/multimap.cons/move_noexcept.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/move_noexcept.pass.cpp
index 0f31f04ff829..8932b4f83d48 100644
--- a/test/std/containers/associative/multimap/multimap.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/move_noexcept.pass.cpp
@@ -15,6 +15,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <map>
 #include <cassert>
 
@@ -26,11 +28,11 @@ struct some_comp
 {
     typedef T value_type;
     some_comp(const some_comp&);
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     typedef std::pair<const MoveOnly, MoveOnly> V;
     {
         typedef std::multimap<MoveOnly, MoveOnly> C;
@@ -48,5 +50,4 @@ int main()
         typedef std::multimap<MoveOnly, MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/clear.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/clear.pass.cpp
index fe9b8c8ba128..321f4d0bd000 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/clear.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/clear.pass.cpp
@@ -39,7 +39,7 @@ int main()
         m.clear();
         assert(m.size() == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
         typedef std::pair<int, double> P;
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/emplace.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/emplace.pass.cpp
index 03da4af59372..7f5b698fa068 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/emplace.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/emplace.pass.cpp
@@ -84,7 +84,7 @@ int main()
         assert(m.begin()->first == 2);
         assert(m.begin()->second == 3.5);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::multimap<int, DefaultOnly, std::less<int>, min_allocator<std::pair<const int, DefaultOnly>>> M;
         typedef M::iterator R;
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/emplace_hint.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/emplace_hint.pass.cpp
index 846d5999a17e..a6ed318c7598 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/emplace_hint.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/emplace_hint.pass.cpp
@@ -89,7 +89,7 @@ int main()
         assert(m.begin()->first == 2);
         assert(m.begin()->second == 3.5);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::multimap<int, DefaultOnly, std::less<int>, min_allocator<std::pair<const int, DefaultOnly>>> M;
         typedef M::iterator R;
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/erase_iter.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/erase_iter.pass.cpp
index ba55351c0bde..6729da41378b 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/erase_iter.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/erase_iter.pass.cpp
@@ -155,7 +155,7 @@ int main()
         assert(i == m.begin());
         assert(i == m.end());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
         typedef std::pair<int, double> P;
@@ -284,7 +284,7 @@ int main()
         assert(i == m.end());
     }
 #endif
-#if __cplusplus >= 201402L
+#if TEST_STD_VER >= 14
     {
     //  This is LWG #2059
         typedef TemplateConstructor T;
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/erase_iter_iter.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/erase_iter_iter.pass.cpp
index 4d3789493110..1069542c5430 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/erase_iter_iter.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/erase_iter_iter.pass.cpp
@@ -86,7 +86,7 @@ int main()
         assert(i == m.begin());
         assert(i == m.end());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
         typedef std::pair<int, double> P;
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/erase_key.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/erase_key.pass.cpp
index 33821d3e3596..44a6abef6ed0 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/erase_key.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/erase_key.pass.cpp
@@ -84,7 +84,7 @@ int main()
         assert(m.size() == 0);
         assert(i == 3);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
         typedef std::pair<int, double> P;
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/insert_allocator_requirements.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/insert_allocator_requirements.pass.cpp
new file mode 100644
index 000000000000..225bf67bb1f6
--- /dev/null
+++ b/test/std/containers/associative/multimap/multimap.modifiers/insert_allocator_requirements.pass.cpp
@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <map>
+
+// class multimap
+
+// insert(...)
+
+// UNSUPPORTED: c++98, c++03
+
+#include <map>
+
+#include "container_test_types.h"
+#include "../../../map_allocator_requirement_test_templates.h"
+
+
+int main()
+{
+  testMultimapInsert<TCT::multimap<> >();
+  testMultimapInsertHint<TCT::multimap<> >();
+}
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/insert_cv.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/insert_cv.pass.cpp
index d9afc9d0fdf0..53874311c782 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/insert_cv.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/insert_cv.pass.cpp
@@ -16,66 +16,54 @@
 #include <map>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
-{
-    {
-        typedef std::multimap<int, double> M;
-        typedef M::iterator R;
-        M m;
-        R r = m.insert(M::value_type(2, 2.5));
-        assert(r == m.begin());
-        assert(m.size() == 1);
-        assert(r->first == 2);
-        assert(r->second == 2.5);
+template <class Container>
+void do_insert_test() {
+    typedef Container M;
+    typedef typename M::iterator R;
+    typedef typename M::value_type VT;
+    M m;
+    const VT v1(2, 2.5);
+    R r = m.insert(v1);
+    assert(r == m.begin());
+    assert(m.size() == 1);
+    assert(r->first == 2);
+    assert(r->second == 2.5);
 
-        r = m.insert(M::value_type(1, 1.5));
-        assert(r == m.begin());
-        assert(m.size() == 2);
-        assert(r->first == 1);
-        assert(r->second == 1.5);
+    const VT v2(1, 1.5);
+    r = m.insert(v2);
+    assert(r == m.begin());
+    assert(m.size() == 2);
+    assert(r->first == 1);
+    assert(r->second == 1.5);
 
-        r = m.insert(M::value_type(3, 3.5));
-        assert(r == prev(m.end()));
-        assert(m.size() == 3);
-        assert(r->first == 3);
-        assert(r->second == 3.5);
+    const VT v3(3, 3.5);
+    r = m.insert(v3);
+    assert(r == prev(m.end()));
+    assert(m.size() == 3);
+    assert(r->first == 3);
+    assert(r->second == 3.5);
 
-        r = m.insert(M::value_type(3, 3.5));
-        assert(r == prev(m.end()));
-        assert(m.size() == 4);
-        assert(r->first == 3);
-        assert(r->second == 3.5);
+    const VT v4(3, 3.5);
+    r = m.insert(v4);
+    assert(r == prev(m.end()));
+    assert(m.size() == 4);
+    assert(r->first == 3);
+    assert(r->second == 3.5);
+}
+
+int main()
+{
+    {
+        typedef std::multimap<int, double> Container;
+        do_insert_test<Container>();
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
-        typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
-        typedef M::iterator R;
-        M m;
-        R r = m.insert(M::value_type(2, 2.5));
-        assert(r == m.begin());
-        assert(m.size() == 1);
-        assert(r->first == 2);
-        assert(r->second == 2.5);
-
-        r = m.insert(M::value_type(1, 1.5));
-        assert(r == m.begin());
-        assert(m.size() == 2);
-        assert(r->first == 1);
-        assert(r->second == 1.5);
-
-        r = m.insert(M::value_type(3, 3.5));
-        assert(r == prev(m.end()));
-        assert(m.size() == 3);
-        assert(r->first == 3);
-        assert(r->second == 3.5);
-
-        r = m.insert(M::value_type(3, 3.5));
-        assert(r == prev(m.end()));
-        assert(m.size() == 4);
-        assert(r->first == 3);
-        assert(r->second == 3.5);
+        typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> Container;
+        do_insert_test<Container>();
     }
 #endif
 }
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/insert_initializer_list.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/insert_initializer_list.pass.cpp
index 5e1a1d4125ef..89befb3e9971 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/insert_initializer_list.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/insert_initializer_list.pass.cpp
@@ -53,7 +53,7 @@ int main()
     assert(*++i == V(3, 2));
     assert(*++i == V(3, 1.5));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> C;
     typedef C::value_type V;
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_cv.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_cv.pass.cpp
index b83c802c04cf..05e1096cb547 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_cv.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_cv.pass.cpp
@@ -16,66 +16,52 @@
 #include <map>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+template <class Container>
+void do_insert_hint_test()
 {
-    {
-        typedef std::multimap<int, double> M;
-        typedef M::iterator R;
-        M m;
-        R r = m.insert(m.end(), M::value_type(2, 2.5));
-        assert(r == m.begin());
-        assert(m.size() == 1);
-        assert(r->first == 2);
-        assert(r->second == 2.5);
+    typedef Container M;
+    typedef typename M::iterator R;
+    typedef typename M::value_type VT;
+    M m;
+    const VT v1(2, 2.5);
+    R r = m.insert(m.end(), v1);
+    assert(r == m.begin());
+    assert(m.size() == 1);
+    assert(r->first == 2);
+    assert(r->second == 2.5);
 
-        r = m.insert(m.end(), M::value_type(1, 1.5));
-        assert(r == m.begin());
-        assert(m.size() == 2);
-        assert(r->first == 1);
-        assert(r->second == 1.5);
+    const VT v2(1, 1.5);
+    r = m.insert(m.end(), v2);
+    assert(r == m.begin());
+    assert(m.size() == 2);
+    assert(r->first == 1);
+    assert(r->second == 1.5);
 
-        r = m.insert(m.end(), M::value_type(3, 3.5));
-        assert(r == prev(m.end()));
-        assert(m.size() == 3);
-        assert(r->first == 3);
-        assert(r->second == 3.5);
+    const VT v3(3, 3.5);
+    r = m.insert(m.end(), v3);
+    assert(r == prev(m.end()));
+    assert(m.size() == 3);
+    assert(r->first == 3);
+    assert(r->second == 3.5);
 
-        r = m.insert(prev(m.end()), M::value_type(3, 4.5));
-        assert(r == prev(m.end(), 2));
-        assert(m.size() == 4);
-        assert(r->first == 3);
-        assert(r->second == 4.5);
-    }
-#if __cplusplus >= 201103L
+    const VT v4(3, 4.5);
+    r = m.insert(prev(m.end()), v4);
+    assert(r == prev(m.end(), 2));
+    assert(m.size() == 4);
+    assert(r->first == 3);
+    assert(r->second == 4.5);
+}
+
+int main()
+{
+    do_insert_hint_test<std::multimap<int, double> >();
+#if TEST_STD_VER >= 11
     {
         typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
-        typedef M::iterator R;
-        M m;
-        R r = m.insert(m.end(), M::value_type(2, 2.5));
-        assert(r == m.begin());
-        assert(m.size() == 1);
-        assert(r->first == 2);
-        assert(r->second == 2.5);
-
-        r = m.insert(m.end(), M::value_type(1, 1.5));
-        assert(r == m.begin());
-        assert(m.size() == 2);
-        assert(r->first == 1);
-        assert(r->second == 1.5);
-
-        r = m.insert(m.end(), M::value_type(3, 3.5));
-        assert(r == prev(m.end()));
-        assert(m.size() == 3);
-        assert(r->first == 3);
-        assert(r->second == 3.5);
-
-        r = m.insert(prev(m.end()), M::value_type(3, 4.5));
-        assert(r == prev(m.end(), 2));
-        assert(m.size() == 4);
-        assert(r->first == 3);
-        assert(r->second == 4.5);
+        do_insert_hint_test<M>();
     }
 #endif
 }
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_iter.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_iter.pass.cpp
index 70ff7ef6d6b8..1bf437a93443 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_iter.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_iter.pass.cpp
@@ -59,7 +59,7 @@ int main()
         assert(next(m.begin(), 8)->first == 3);
         assert(next(m.begin(), 8)->second == 2);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
         typedef std::pair<int, double> P;
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_rv.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_rv.pass.cpp
index 7035de83f990..47e0d371bb48 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_rv.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_rv.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <map>
 
 // class multimap
@@ -21,73 +23,53 @@
 #include "min_allocator.h"
 #include "test_macros.h"
 
-int main()
+template <class Container, class Pair>
+void do_insert_rv_test()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    {
-        typedef std::multimap<int, MoveOnly> M;
-        typedef std::pair<int, MoveOnly> P;
-        typedef M::iterator R;
-        M m;
-        R r = m.insert(m.cend(), P(2, 2));
-        assert(r == m.begin());
-        assert(m.size() == 1);
-        assert(r->first == 2);
-        assert(r->second == 2);
+    typedef Container M;
+    typedef Pair P;
+    typedef typename M::iterator R;
+    M m;
+    R r = m.insert(m.cend(), P(2, 2));
+    assert(r == m.begin());
+    assert(m.size() == 1);
+    assert(r->first == 2);
+    assert(r->second == 2);
 
-        r = m.insert(m.cend(), P(1, 1));
-        assert(r == m.begin());
-        assert(m.size() == 2);
-        assert(r->first == 1);
-        assert(r->second == 1);
+    r = m.insert(m.cend(), P(1, 1));
+    assert(r == m.begin());
+    assert(m.size() == 2);
+    assert(r->first == 1);
+    assert(r->second == 1);
 
-        r = m.insert(m.cend(), P(3, 3));
-        assert(r == prev(m.end()));
-        assert(m.size() == 3);
-        assert(r->first == 3);
-        assert(r->second == 3);
+    r = m.insert(m.cend(), P(3, 3));
+    assert(r == prev(m.end()));
+    assert(m.size() == 3);
+    assert(r->first == 3);
+    assert(r->second == 3);
+
+    r = m.insert(m.cend(), P(3, 2));
+    assert(r == prev(m.end()));
+    assert(m.size() == 4);
+    assert(r->first == 3);
+    assert(r->second == 2);
+}
+
+int main()
+{
+    do_insert_rv_test<std::multimap<int, MoveOnly>, std::pair<int, MoveOnly> >();
+    do_insert_rv_test<std::multimap<int, MoveOnly>, std::pair<const int, MoveOnly> >();
 
-        r = m.insert(m.cend(), P(3, 2));
-        assert(r == prev(m.end()));
-        assert(m.size() == 4);
-        assert(r->first == 3);
-        assert(r->second == 2);
-    }
-#if TEST_STD_VER >= 11
     {
         typedef std::multimap<int, MoveOnly, std::less<int>, min_allocator<std::pair<const int, MoveOnly>>> M;
         typedef std::pair<int, MoveOnly> P;
-        typedef M::iterator R;
-        M m;
-        R r = m.insert(m.cend(), P(2, 2));
-        assert(r == m.begin());
-        assert(m.size() == 1);
-        assert(r->first == 2);
-        assert(r->second == 2);
+        typedef std::pair<const int, MoveOnly> CP;
+        do_insert_rv_test<M, P>();
+        do_insert_rv_test<M, CP>();
 
-        r = m.insert(m.cend(), P(1, 1));
-        assert(r == m.begin());
-        assert(m.size() == 2);
-        assert(r->first == 1);
-        assert(r->second == 1);
-
-        r = m.insert(m.cend(), P(3, 3));
-        assert(r == prev(m.end()));
-        assert(m.size() == 3);
-        assert(r->first == 3);
-        assert(r->second == 3);
-
-        r = m.insert(m.cend(), P(3, 2));
-        assert(r == prev(m.end()));
-        assert(m.size() == 4);
-        assert(r->first == 3);
-        assert(r->second == 2);
     }
-#endif
-#if TEST_STD_VER > 14
     {
         typedef std::multimap<int, MoveOnly> M;
-        typedef std::pair<int, MoveOnly> P;
         typedef M::iterator R;
         M m;
         R r = m.insert(m.cend(), {2, MoveOnly(2)});
@@ -114,6 +96,4 @@ int main()
         assert(r->first == 3);
         assert(r->second == 2);
     }
-#endif
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/insert_rv.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/insert_rv.pass.cpp
index 825e304f65a8..022de873f7f1 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/insert_rv.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/insert_rv.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <map>
 
 // class multimap
@@ -21,68 +23,45 @@
 #include "min_allocator.h"
 #include "test_macros.h"
 
-int main()
+template <class Container>
+void do_insert_rv_test()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    {
-        typedef std::multimap<int, MoveOnly> M;
-        typedef M::iterator R;
-        M m;
-        R r = m.insert(M::value_type(2, 2));
-        assert(r == m.begin());
-        assert(m.size() == 1);
-        assert(r->first == 2);
-        assert(r->second == 2);
+    typedef std::multimap<int, MoveOnly> M;
+    typedef typename M::iterator R;
+    typedef typename M::value_type VT;
+    M m;
+    R r = m.insert(VT(2, 2));
+    assert(r == m.begin());
+    assert(m.size() == 1);
+    assert(r->first == 2);
+    assert(r->second == 2);
 
-        r = m.insert(M::value_type(1, 1));
-        assert(r == m.begin());
-        assert(m.size() == 2);
-        assert(r->first == 1);
-        assert(r->second == 1);
+    r = m.insert(VT(1, 1));
+    assert(r == m.begin());
+    assert(m.size() == 2);
+    assert(r->first == 1);
+    assert(r->second == 1);
 
-        r = m.insert(M::value_type(3, 3));
-        assert(r == prev(m.end()));
-        assert(m.size() == 3);
-        assert(r->first == 3);
-        assert(r->second == 3);
+    r = m.insert(VT(3, 3));
+    assert(r == prev(m.end()));
+    assert(m.size() == 3);
+    assert(r->first == 3);
+    assert(r->second == 3);
 
-        r = m.insert(M::value_type(3, 3));
-        assert(r == prev(m.end()));
-        assert(m.size() == 4);
-        assert(r->first == 3);
-        assert(r->second == 3);
-    }
-#if TEST_STD_VER >= 11
+    r = m.insert(VT(3, 3));
+    assert(r == prev(m.end()));
+    assert(m.size() == 4);
+    assert(r->first == 3);
+    assert(r->second == 3);
+}
+
+int main()
+{
+    do_insert_rv_test<std::multimap<int, MoveOnly>>();
     {
         typedef std::multimap<int, MoveOnly, std::less<int>, min_allocator<std::pair<const int, MoveOnly>>> M;
-        typedef M::iterator R;
-        M m;
-        R r = m.insert(M::value_type(2, 2));
-        assert(r == m.begin());
-        assert(m.size() == 1);
-        assert(r->first == 2);
-        assert(r->second == 2);
-
-        r = m.insert(M::value_type(1, 1));
-        assert(r == m.begin());
-        assert(m.size() == 2);
-        assert(r->first == 1);
-        assert(r->second == 1);
-
-        r = m.insert(M::value_type(3, 3));
-        assert(r == prev(m.end()));
-        assert(m.size() == 3);
-        assert(r->first == 3);
-        assert(r->second == 3);
-
-        r = m.insert(M::value_type(3, 3));
-        assert(r == prev(m.end()));
-        assert(m.size() == 4);
-        assert(r->first == 3);
-        assert(r->second == 3);
+        do_insert_rv_test<M>();
     }
-#endif
-#if TEST_STD_VER > 14
     {
         typedef std::multimap<int, MoveOnly> M;
         typedef M::iterator R;
@@ -111,6 +90,4 @@ int main()
         assert(r->first == 3);
         assert(r->second == 3);
     }
-#endif
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/containers/associative/multimap/multimap.ops/count.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/count.pass.cpp
index c666c295f3a0..92f90f551d44 100644
--- a/test/std/containers/associative/multimap/multimap.ops/count.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/count.pass.cpp
@@ -56,7 +56,7 @@ int main()
         assert(r == 0);
     }
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
     {
diff --git a/test/std/containers/associative/multimap/multimap.ops/count0.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/count0.pass.cpp
index 7da13bb0d66d..b993f4f89087 100644
--- a/test/std/containers/associative/multimap/multimap.ops/count0.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/count0.pass.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// XFAIL: c++03, c++11
+// XFAIL: c++98, c++03, c++11
 
 // <map>
 
@@ -15,9 +15,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/count1.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/count1.fail.cpp
index f30d1bfd88d6..d0f3f1c0fdb7 100644
--- a/test/std/containers/associative/multimap/multimap.ops/count1.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/count1.fail.cpp
@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/count2.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/count2.fail.cpp
index ffb7eb6a559a..86d492f7f5e0 100644
--- a/test/std/containers/associative/multimap/multimap.ops/count2.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/count2.fail.cpp
@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/count3.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/count3.fail.cpp
index 4bb9d14634f3..55095efb3d6a 100644
--- a/test/std/containers/associative/multimap/multimap.ops/count3.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/count3.fail.cpp
@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/equal_range.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/equal_range.pass.cpp
index 5a071042461a..31eac26816ac 100644
--- a/test/std/containers/associative/multimap/multimap.ops/equal_range.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/equal_range.pass.cpp
@@ -101,7 +101,7 @@ int main()
         assert(r.second == m.end());
     }
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
     {
diff --git a/test/std/containers/associative/multimap/multimap.ops/equal_range0.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/equal_range0.pass.cpp
index c0f07468ec5e..a3a51e6ccbf9 100644
--- a/test/std/containers/associative/multimap/multimap.ops/equal_range0.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/equal_range0.pass.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// XFAIL: c++03, c++11
+// XFAIL: c++98, c++03, c++11
 
 // <map>
 
@@ -15,9 +15,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/equal_range1.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/equal_range1.fail.cpp
index f022e94324fd..f793bf8859ba 100644
--- a/test/std/containers/associative/multimap/multimap.ops/equal_range1.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/equal_range1.fail.cpp
@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/equal_range2.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/equal_range2.fail.cpp
index 695e71703e3b..d099a8c81a1b 100644
--- a/test/std/containers/associative/multimap/multimap.ops/equal_range2.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/equal_range2.fail.cpp
@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/equal_range3.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/equal_range3.fail.cpp
index 59c2855e8f69..e53fff942793 100644
--- a/test/std/containers/associative/multimap/multimap.ops/equal_range3.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/equal_range3.fail.cpp
@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/find.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/find.pass.cpp
index a60e42cf8592..2fd8c05b5f5e 100644
--- a/test/std/containers/associative/multimap/multimap.ops/find.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/find.pass.cpp
@@ -83,7 +83,7 @@ int main()
         assert(r == m.end());
     }
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
     {
diff --git a/test/std/containers/associative/multimap/multimap.ops/find0.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/find0.pass.cpp
index 4f3369870c8f..03a6e1883051 100644
--- a/test/std/containers/associative/multimap/multimap.ops/find0.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/find0.pass.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// XFAIL: c++03, c++11
+// XFAIL: c++98, c++03, c++11
 
 // <map>
 
@@ -15,9 +15,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/find1.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/find1.fail.cpp
index e1eef034064d..2759af46be14 100644
--- a/test/std/containers/associative/multimap/multimap.ops/find1.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/find1.fail.cpp
@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/find2.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/find2.fail.cpp
index 4c03f583fa1c..c67f3b39dabd 100644
--- a/test/std/containers/associative/multimap/multimap.ops/find2.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/find2.fail.cpp
@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/find3.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/find3.fail.cpp
index f10bc60aa864..e53fc4d55887 100644
--- a/test/std/containers/associative/multimap/multimap.ops/find3.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/find3.fail.cpp
@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/lower_bound.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/lower_bound.pass.cpp
index 38b931802f8e..5c0315f956a8 100644
--- a/test/std/containers/associative/multimap/multimap.ops/lower_bound.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/lower_bound.pass.cpp
@@ -87,7 +87,7 @@ int main()
         assert(r == m.end());
     }
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
     {
diff --git a/test/std/containers/associative/multimap/multimap.ops/lower_bound0.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/lower_bound0.pass.cpp
index c5271f65d7e5..77927bb5abed 100644
--- a/test/std/containers/associative/multimap/multimap.ops/lower_bound0.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/lower_bound0.pass.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// XFAIL: c++03, c++11
+// XFAIL: c++98, c++03, c++11
 
 // <map>
 
@@ -15,9 +15,9 @@
 
 //       iterator lower_bound(const key_type& k);
 // const_iterator lower_bound(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/lower_bound1.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/lower_bound1.fail.cpp
index b452be864e2b..9b39573a5f42 100644
--- a/test/std/containers/associative/multimap/multimap.ops/lower_bound1.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/lower_bound1.fail.cpp
@@ -13,9 +13,9 @@
 
 //       iterator lower_bound(const key_type& k);
 // const_iterator lower_bound(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/lower_bound2.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/lower_bound2.fail.cpp
index a2ba30236a40..68710bd1bc38 100644
--- a/test/std/containers/associative/multimap/multimap.ops/lower_bound2.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/lower_bound2.fail.cpp
@@ -13,9 +13,9 @@
 
 //       iterator lower_bound(const key_type& k);
 // const_iterator lower_bound(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/lower_bound3.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/lower_bound3.fail.cpp
index 50d9fca91ad9..f254ef4785a1 100644
--- a/test/std/containers/associative/multimap/multimap.ops/lower_bound3.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/lower_bound3.fail.cpp
@@ -13,9 +13,9 @@
 
 //       iterator lower_bound(const key_type& k);
 // const_iterator lower_bound(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/upper_bound.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/upper_bound.pass.cpp
index 7c647a9426cb..012354cef7bb 100644
--- a/test/std/containers/associative/multimap/multimap.ops/upper_bound.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/upper_bound.pass.cpp
@@ -87,7 +87,7 @@ int main()
         assert(r == m.end());
     }
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
     {
diff --git a/test/std/containers/associative/multimap/multimap.ops/upper_bound0.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/upper_bound0.pass.cpp
index 322c6f55130c..3f6852d085c3 100644
--- a/test/std/containers/associative/multimap/multimap.ops/upper_bound0.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/upper_bound0.pass.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// XFAIL: c++03, c++11
+// XFAIL: c++98, c++03, c++11
 
 // <map>
 
@@ -15,9 +15,9 @@
 
 //       iterator upper_bound(const key_type& k);
 // const_iterator upper_bound(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/upper_bound1.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/upper_bound1.fail.cpp
index bb78ad698160..d47d7bfc89f4 100644
--- a/test/std/containers/associative/multimap/multimap.ops/upper_bound1.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/upper_bound1.fail.cpp
@@ -13,9 +13,9 @@
 
 //       iterator upper_bound(const key_type& k);
 // const_iterator upper_bound(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/upper_bound2.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/upper_bound2.fail.cpp
index a79d5938e56e..a3da9d82c95c 100644
--- a/test/std/containers/associative/multimap/multimap.ops/upper_bound2.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/upper_bound2.fail.cpp
@@ -13,9 +13,9 @@
 
 //       iterator upper_bound(const key_type& k);
 // const_iterator upper_bound(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/upper_bound3.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/upper_bound3.fail.cpp
index 1c1dc74b72c7..6ffdb206cc30 100644
--- a/test/std/containers/associative/multimap/multimap.ops/upper_bound3.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/upper_bound3.fail.cpp
@@ -13,9 +13,9 @@
 
 //       iterator upper_bound(const key_type& k);
 // const_iterator upper_bound(const key_type& k) const;
-// 
-//   The member function templates find, count, lower_bound, upper_bound, and 
-// equal_range shall not participate in overload resolution unless the 
+//
+//   The member function templates find, count, lower_bound, upper_bound, and
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
diff --git a/test/std/containers/associative/multimap/multimap.special/member_swap.pass.cpp b/test/std/containers/associative/multimap/multimap.special/member_swap.pass.cpp
index fb17e7340bd4..f216f9f76a11 100644
--- a/test/std/containers/associative/multimap/multimap.special/member_swap.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.special/member_swap.pass.cpp
@@ -96,7 +96,7 @@ int main()
         assert(m2 == m1_save);
     }
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
     {
diff --git a/test/std/containers/associative/multimap/multimap.special/non_member_swap.pass.cpp b/test/std/containers/associative/multimap/multimap.special/non_member_swap.pass.cpp
index a91dfebb14a9..a075919bba9a 100644
--- a/test/std/containers/associative/multimap/multimap.special/non_member_swap.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.special/non_member_swap.pass.cpp
@@ -98,6 +98,7 @@ int main()
         assert(m1 == m2_save);
         assert(m2 == m1_save);
     }
+    }
     {
         typedef test_allocator<V> A;
         typedef test_compare<std::less<int> > C;
@@ -166,8 +167,7 @@ int main()
         assert(m2.key_comp() == C(1));
         assert(m2.get_allocator() == A(1));
     }
-    }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
     {
@@ -242,6 +242,7 @@ int main()
         assert(m1 == m2_save);
         assert(m2 == m1_save);
     }
+    }
     {
         typedef min_allocator<V> A;
         typedef test_compare<std::less<int> > C;
@@ -276,6 +277,5 @@ int main()
         assert(m2.key_comp() == C(1));
         assert(m2.get_allocator() == A());
     }
-    }
 #endif
 }
diff --git a/test/std/containers/associative/multimap/multimap.special/swap_noexcept.pass.cpp b/test/std/containers/associative/multimap/multimap.special/swap_noexcept.pass.cpp
index e70ee1fae565..ffc71b0eeb92 100644
--- a/test/std/containers/associative/multimap/multimap.special/swap_noexcept.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.special/swap_noexcept.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <map>
 
 // void swap(multimap& c)
@@ -15,13 +17,14 @@
 //
 //  In C++17, the standard says that swap shall have:
 //     noexcept(allocator_traits<Allocator>::is_always_equal::value &&
-//              noexcept(swap(declval<Compare&>(), declval<Compare&>())));                 
+//              noexcept(swap(declval<Compare&>(), declval<Compare&>())));
 
 // This tests a conforming extension
 
 #include <map>
 #include <cassert>
 
+#include "test_macros.h"
 #include "MoveOnly.h"
 #include "test_allocator.h"
 
@@ -29,23 +32,20 @@ template <class T>
 struct some_comp
 {
     typedef T value_type;
-    
+
     some_comp() {}
     some_comp(const some_comp&) {}
-    void deallocate(void*, unsigned) {}
-
-    typedef std::true_type propagate_on_container_swap;
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 template <class T>
 struct some_comp2
 {
     typedef T value_type;
-    
+
     some_comp2() {}
     some_comp2(const some_comp2&) {}
-    void deallocate(void*, unsigned) {}
-    typedef std::true_type propagate_on_container_swap;
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 #if TEST_STD_VER >= 14
@@ -57,7 +57,7 @@ template <class T>
 struct some_alloc
 {
     typedef T value_type;
-    
+
     some_alloc() {}
     some_alloc(const some_alloc&);
     void deallocate(void*, unsigned) {}
@@ -69,7 +69,7 @@ template <class T>
 struct some_alloc2
 {
     typedef T value_type;
-    
+
     some_alloc2() {}
     some_alloc2(const some_alloc2&);
     void deallocate(void*, unsigned) {}
@@ -82,7 +82,7 @@ template <class T>
 struct some_alloc3
 {
     typedef T value_type;
-    
+
     some_alloc3() {}
     some_alloc3(const some_alloc3&);
     void deallocate(void*, unsigned) {}
@@ -93,7 +93,6 @@ struct some_alloc3
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     typedef std::pair<const MoveOnly, MoveOnly> V;
     {
         typedef std::multimap<MoveOnly, MoveOnly> C;
@@ -144,6 +143,4 @@ int main()
     static_assert( noexcept(swap(c1, c2)), "");
     }
 #endif
-
-#endif
 }
diff --git a/test/std/containers/associative/multimap/size.pass.cpp b/test/std/containers/associative/multimap/size.pass.cpp
index ac71d4c95b64..7ba7ceb2be6e 100644
--- a/test/std/containers/associative/multimap/size.pass.cpp
+++ b/test/std/containers/associative/multimap/size.pass.cpp
@@ -37,7 +37,7 @@ int main()
     m.erase(m.begin());
     assert(m.size() == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
     M m;
diff --git a/test/std/containers/associative/multimap/types.pass.cpp b/test/std/containers/associative/multimap/types.pass.cpp
index a0f4db056a83..999ecbb7c223 100644
--- a/test/std/containers/associative/multimap/types.pass.cpp
+++ b/test/std/containers/associative/multimap/types.pass.cpp
@@ -50,7 +50,7 @@ int main()
     static_assert((std::is_same<C::size_type, std::size_t>::value), "");
     static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> C;
     static_assert((std::is_same<C::key_type, int>::value), "");
diff --git a/test/std/containers/associative/multiset/clear.pass.cpp b/test/std/containers/associative/multiset/clear.pass.cpp
index 3069de5a300d..f762ef7d3504 100644
--- a/test/std/containers/associative/multiset/clear.pass.cpp
+++ b/test/std/containers/associative/multiset/clear.pass.cpp
@@ -39,7 +39,7 @@ int main()
         m.clear();
         assert(m.size() == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
         typedef int V;
diff --git a/test/std/containers/associative/multiset/count.pass.cpp b/test/std/containers/associative/multiset/count.pass.cpp
index 93bd6f80eaad..997a949388cf 100644
--- a/test/std/containers/associative/multiset/count.pass.cpp
+++ b/test/std/containers/associative/multiset/count.pass.cpp
@@ -55,7 +55,7 @@ int main()
         assert(r == 0);
     }
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef int V;
     typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
diff --git a/test/std/containers/associative/multiset/emplace.pass.cpp b/test/std/containers/associative/multiset/emplace.pass.cpp
index 450ee6cd35a3..93842a250f8e 100644
--- a/test/std/containers/associative/multiset/emplace.pass.cpp
+++ b/test/std/containers/associative/multiset/emplace.pass.cpp
@@ -68,7 +68,7 @@ int main()
         assert(m.size() == 1);
         assert(*r == 2);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
         typedef M::iterator R;
diff --git a/test/std/containers/associative/multiset/emplace_hint.pass.cpp b/test/std/containers/associative/multiset/emplace_hint.pass.cpp
index 194adf761c4c..48519fd4356a 100644
--- a/test/std/containers/associative/multiset/emplace_hint.pass.cpp
+++ b/test/std/containers/associative/multiset/emplace_hint.pass.cpp
@@ -68,7 +68,7 @@ int main()
         assert(m.size() == 1);
         assert(*r == 2);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
         typedef M::iterator R;
diff --git a/test/std/containers/associative/multiset/empty.pass.cpp b/test/std/containers/associative/multiset/empty.pass.cpp
index 32aef90d4188..acca4e021e0c 100644
--- a/test/std/containers/associative/multiset/empty.pass.cpp
+++ b/test/std/containers/associative/multiset/empty.pass.cpp
@@ -29,7 +29,7 @@ int main()
     m.clear();
     assert(m.empty());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
     M m;
diff --git a/test/std/containers/associative/multiset/equal_range.pass.cpp b/test/std/containers/associative/multiset/equal_range.pass.cpp
index 8c69d0c61ec5..7ab95cfb8f67 100644
--- a/test/std/containers/associative/multiset/equal_range.pass.cpp
+++ b/test/std/containers/associative/multiset/equal_range.pass.cpp
@@ -100,7 +100,7 @@ int main()
         assert(r.second == next(m.begin(), 9));
     }
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef int V;
     typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
diff --git a/test/std/containers/associative/multiset/erase_iter.pass.cpp b/test/std/containers/associative/multiset/erase_iter.pass.cpp
index 1d41540edb8a..8ee45c64cff0 100644
--- a/test/std/containers/associative/multiset/erase_iter.pass.cpp
+++ b/test/std/containers/associative/multiset/erase_iter.pass.cpp
@@ -106,7 +106,7 @@ int main()
         assert(i == m.begin());
         assert(i == m.end());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
         typedef int V;
@@ -186,7 +186,7 @@ int main()
         assert(i == m.end());
     }
 #endif
-#if __cplusplus >= 201402L
+#if TEST_STD_VER >= 14
     {
     //  This is LWG #2059
         typedef TemplateConstructor T;
diff --git a/test/std/containers/associative/multiset/erase_iter_iter.pass.cpp b/test/std/containers/associative/multiset/erase_iter_iter.pass.cpp
index e1d7090d816f..70d3477907e3 100644
--- a/test/std/containers/associative/multiset/erase_iter_iter.pass.cpp
+++ b/test/std/containers/associative/multiset/erase_iter_iter.pass.cpp
@@ -78,7 +78,7 @@ int main()
         assert(m.size() == 0);
         assert(i == m.end());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
         typedef int V;
diff --git a/test/std/containers/associative/multiset/erase_key.pass.cpp b/test/std/containers/associative/multiset/erase_key.pass.cpp
index e9bce1e1b640..7293bcfb2c35 100644
--- a/test/std/containers/associative/multiset/erase_key.pass.cpp
+++ b/test/std/containers/associative/multiset/erase_key.pass.cpp
@@ -72,7 +72,7 @@ int main()
         assert(m.size() == 0);
         assert(i == 3);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
         typedef int V;
diff --git a/test/std/containers/associative/multiset/find.pass.cpp b/test/std/containers/associative/multiset/find.pass.cpp
index 364460a6ca3a..3b7d96fe9110 100644
--- a/test/std/containers/associative/multiset/find.pass.cpp
+++ b/test/std/containers/associative/multiset/find.pass.cpp
@@ -92,7 +92,7 @@ int main()
             assert(r == next(m.begin(), 8));
         }
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int V;
         typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
diff --git a/test/std/containers/associative/multiset/incomplete_type.pass.cpp b/test/std/containers/associative/multiset/incomplete_type.pass.cpp
new file mode 100644
index 000000000000..0355e18f9f29
--- /dev/null
+++ b/test/std/containers/associative/multiset/incomplete_type.pass.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <set>
+
+// Check that std::multiset and it's iterators can be instantiated with an incomplete
+// type.
+
+#include <set>
+
+struct A {
+    typedef std::multiset<A> Set;
+    int data;
+    Set m;
+    Set::iterator it;
+    Set::const_iterator cit;
+};
+
+inline bool operator==(A const& L, A const& R) { return &L == &R; }
+inline bool operator<(A const& L, A const& R)  { return L.data < R.data; }
+int main() {
+    A a;
+}
diff --git a/test/std/containers/associative/multiset/insert_allocator_requirements.pass.cpp b/test/std/containers/associative/multiset/insert_allocator_requirements.pass.cpp
new file mode 100644
index 000000000000..a280d10d5ab2
--- /dev/null
+++ b/test/std/containers/associative/multiset/insert_allocator_requirements.pass.cpp
@@ -0,0 +1,26 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <set>
+
+// class multiset
+
+// insert(...)
+
+// UNSUPPORTED: c++98, c++03
+
+#include <set>
+
+#include "container_test_types.h"
+#include "../../set_allocator_requirement_test_templates.h"
+
+int main()
+{
+  testMultisetInsert<TCT::multiset<> >();
+}
diff --git a/test/std/containers/associative/multiset/insert_cv.pass.cpp b/test/std/containers/associative/multiset/insert_cv.pass.cpp
index 179715753ab0..2aa920d70972 100644
--- a/test/std/containers/associative/multiset/insert_cv.pass.cpp
+++ b/test/std/containers/associative/multiset/insert_cv.pass.cpp
@@ -44,7 +44,7 @@ int main()
         assert(m.size() == 4);
         assert(*r == 3);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
         typedef M::iterator R;
diff --git a/test/std/containers/associative/multiset/insert_initializer_list.pass.cpp b/test/std/containers/associative/multiset/insert_initializer_list.pass.cpp
index 7e923f2516dd..7b82cea5fbea 100644
--- a/test/std/containers/associative/multiset/insert_initializer_list.pass.cpp
+++ b/test/std/containers/associative/multiset/insert_initializer_list.pass.cpp
@@ -39,7 +39,7 @@ int main()
     assert(*++i == V(10));
     }
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::multiset<int, std::less<int>, min_allocator<int>> C;
     typedef C::value_type V;
diff --git a/test/std/containers/associative/multiset/insert_iter_cv.pass.cpp b/test/std/containers/associative/multiset/insert_iter_cv.pass.cpp
index 7d204024c212..ca08bacad2f1 100644
--- a/test/std/containers/associative/multiset/insert_iter_cv.pass.cpp
+++ b/test/std/containers/associative/multiset/insert_iter_cv.pass.cpp
@@ -44,7 +44,7 @@ int main()
         assert(m.size() == 4);
         assert(*r == 3);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
         typedef M::iterator R;
diff --git a/test/std/containers/associative/multiset/insert_iter_iter.pass.cpp b/test/std/containers/associative/multiset/insert_iter_iter.pass.cpp
index 189c45498669..fb664d74e4be 100644
--- a/test/std/containers/associative/multiset/insert_iter_iter.pass.cpp
+++ b/test/std/containers/associative/multiset/insert_iter_iter.pass.cpp
@@ -51,7 +51,7 @@ int main()
         assert(*next(m.begin(), 7) == 3);
         assert(*next(m.begin(), 8) == 3);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
         typedef int V;
diff --git a/test/std/containers/associative/multiset/insert_iter_rv.pass.cpp b/test/std/containers/associative/multiset/insert_iter_rv.pass.cpp
index ee631f005c93..0afc8dc87c23 100644
--- a/test/std/containers/associative/multiset/insert_iter_rv.pass.cpp
+++ b/test/std/containers/associative/multiset/insert_iter_rv.pass.cpp
@@ -47,7 +47,7 @@ int main()
         assert(*r == 3);
     }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::multiset<MoveOnly, std::less<MoveOnly>, min_allocator<MoveOnly>> M;
         typedef M::iterator R;
diff --git a/test/std/containers/associative/multiset/insert_rv.pass.cpp b/test/std/containers/associative/multiset/insert_rv.pass.cpp
index 29c233e9a119..3ee464bc5bc7 100644
--- a/test/std/containers/associative/multiset/insert_rv.pass.cpp
+++ b/test/std/containers/associative/multiset/insert_rv.pass.cpp
@@ -47,7 +47,7 @@ int main()
         assert(*r == 3);
     }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::multiset<MoveOnly, std::less<MoveOnly>, min_allocator<MoveOnly>> M;
         typedef M::iterator R;
diff --git a/test/std/containers/associative/multiset/iterator.pass.cpp b/test/std/containers/associative/multiset/iterator.pass.cpp
index d1f0ecfd6aa0..c152a4398196 100644
--- a/test/std/containers/associative/multiset/iterator.pass.cpp
+++ b/test/std/containers/associative/multiset/iterator.pass.cpp
@@ -70,7 +70,7 @@ int main()
         std::multiset<int>::const_iterator k = i;
         assert(i == k);
         for (int j = 1; j <= 8; ++j)
-            for (int k = 0; k < 3; ++k, ++i)
+            for (int n = 0; n < 3; ++n, ++i)
                 assert(*i == j);
     }
     {
@@ -113,7 +113,7 @@ int main()
             for (int k = 0; k < 3; ++k, ++i)
                 assert(*i == j);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int V;
         V ar[] =
@@ -151,7 +151,7 @@ int main()
         std::multiset<int, std::less<int>, min_allocator<int>>::const_iterator k = i;
         assert(i == k);
         for (int j = 1; j <= 8; ++j)
-            for (int k = 0; k < 3; ++k, ++i)
+            for (int n = 0; n < 3; ++n, ++i)
                 assert(*i == j);
     }
     {
diff --git a/test/std/containers/associative/multiset/lower_bound.pass.cpp b/test/std/containers/associative/multiset/lower_bound.pass.cpp
index e466791d9356..ae8cfe6eff4d 100644
--- a/test/std/containers/associative/multiset/lower_bound.pass.cpp
+++ b/test/std/containers/associative/multiset/lower_bound.pass.cpp
@@ -86,7 +86,7 @@ int main()
             assert(r == next(m.begin(), 9));
         }
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int V;
         typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
diff --git a/test/std/containers/associative/multiset/max_size.pass.cpp b/test/std/containers/associative/multiset/max_size.pass.cpp
index 5524f771b341..79492c9b1c40 100644
--- a/test/std/containers/associative/multiset/max_size.pass.cpp
+++ b/test/std/containers/associative/multiset/max_size.pass.cpp
@@ -25,7 +25,7 @@ int main()
     M m;
     assert(m.max_size() != 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
     M m;
diff --git a/test/std/containers/associative/multiset/multiset.cons/assign_initializer_list.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/assign_initializer_list.pass.cpp
index 7d76581d6d8e..2c5318afd73b 100644
--- a/test/std/containers/associative/multiset/multiset.cons/assign_initializer_list.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/assign_initializer_list.pass.cpp
@@ -37,7 +37,7 @@ int main()
     assert(*++i == V(6));
     }
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::multiset<int, std::less<int>, min_allocator<int>> C;
     typedef C::value_type V;
diff --git a/test/std/containers/associative/multiset/multiset.cons/compare_copy_constructible.fail.cpp b/test/std/containers/associative/multiset/multiset.cons/compare_copy_constructible.fail.cpp
new file mode 100644
index 000000000000..2eade5299d6f
--- /dev/null
+++ b/test/std/containers/associative/multiset/multiset.cons/compare_copy_constructible.fail.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <set>
+
+// Check that std::multiset fails to instantiate if the comparison predicate is 
+// not copy-constructible. This is LWG issue 2436
+
+#include <set>
+
+template <class T>
+struct Comp {
+	bool operator () (const T& lhs, const T& rhs) const { return lhs < rhs; }
+
+	Comp () {}
+private:
+	Comp (const Comp &); // declared but not defined
+	};
+
+
+int main() {
+	std::multiset<int, Comp<int> > m;
+}
diff --git a/test/std/containers/associative/multiset/multiset.cons/default.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/default.pass.cpp
index 5bb0312f012b..0bc50ab7aaf8 100644
--- a/test/std/containers/associative/multiset/multiset.cons/default.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/default.pass.cpp
@@ -25,7 +25,7 @@ int main()
     assert(m.empty());
     assert(m.begin() == m.end());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     std::multiset<int, std::less<int>, min_allocator<int>> m;
     assert(m.empty());
diff --git a/test/std/containers/associative/multiset/multiset.cons/default_noexcept.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/default_noexcept.pass.cpp
index bf8c53b9ee5d..15520e7834ff 100644
--- a/test/std/containers/associative/multiset/multiset.cons/default_noexcept.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/default_noexcept.pass.cpp
@@ -17,9 +17,12 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "MoveOnly.h"
 #include "test_allocator.h"
 
@@ -28,18 +31,18 @@ struct some_comp
 {
     typedef T value_type;
     some_comp();
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::multiset<MoveOnly> C;
-        static_assert(std::is_nothrow_default_constructible<C>::value, "");
+        LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
     }
     {
         typedef std::multiset<MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C;
-        static_assert(std::is_nothrow_default_constructible<C>::value, "");
+        LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
     }
     {
         typedef std::multiset<MoveOnly, std::less<MoveOnly>, other_allocator<MoveOnly>> C;
@@ -49,5 +52,4 @@ int main()
         typedef std::multiset<MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/associative/multiset/multiset.cons/dtor_noexcept.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/dtor_noexcept.pass.cpp
index fd612c06dbbc..f4e868ebbc8f 100644
--- a/test/std/containers/associative/multiset/multiset.cons/dtor_noexcept.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/dtor_noexcept.pass.cpp
@@ -11,26 +11,24 @@
 
 // ~multiset() // implied noexcept;
 
+// UNSUPPORTED: c++98, c++03
+
 #include <set>
 #include <cassert>
 
 #include "MoveOnly.h"
 #include "test_allocator.h"
 
-#if __has_feature(cxx_noexcept)
-
 template <class T>
 struct some_comp
 {
     typedef T value_type;
     ~some_comp() noexcept(false);
+    bool operator()(const T&, const T&) const { return false; }
 };
 
-#endif
-
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::multiset<MoveOnly> C;
         static_assert(std::is_nothrow_destructible<C>::value, "");
@@ -47,5 +45,4 @@ int main()
         typedef std::multiset<MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/associative/multiset/multiset.cons/initializer_list.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/initializer_list.pass.cpp
index dadafec7c3b1..7327bf62646b 100644
--- a/test/std/containers/associative/multiset/multiset.cons/initializer_list.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/initializer_list.pass.cpp
@@ -36,7 +36,7 @@ int main()
     assert(*++i == V(6));
     }
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::multiset<int, std::less<int>, min_allocator<int>> C;
     typedef C::value_type V;
diff --git a/test/std/containers/associative/multiset/multiset.cons/iter_iter.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/iter_iter.pass.cpp
index f6c1fd76de14..ebe8353bab1f 100644
--- a/test/std/containers/associative/multiset/multiset.cons/iter_iter.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/iter_iter.pass.cpp
@@ -50,7 +50,7 @@ int main()
     assert(*next(m.begin(), 7) == 3);
     assert(*next(m.begin(), 8) == 3);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef int V;
     V ar[] =
diff --git a/test/std/containers/associative/multiset/multiset.cons/iter_iter_alloc.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/iter_iter_alloc.pass.cpp
index 4ed00c7124cc..4313f46a03d7 100644
--- a/test/std/containers/associative/multiset/multiset.cons/iter_iter_alloc.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/iter_iter_alloc.pass.cpp
@@ -24,6 +24,7 @@
 
 int main()
 {
+    {
     typedef int V;
     V ar[] =
     {
@@ -55,6 +56,7 @@ int main()
     assert(*next(m.begin(), 6) == 3);
     assert(*next(m.begin(), 7) == 3);
     assert(*next(m.begin(), 8) == 3);
+    }
 #if _LIBCPP_STD_VER > 11
     {
     typedef int V;
diff --git a/test/std/containers/associative/multiset/multiset.cons/move.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/move.pass.cpp
index 40321cd247e1..5a905cf15a08 100644
--- a/test/std/containers/associative/multiset/multiset.cons/move.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/move.pass.cpp
@@ -77,7 +77,7 @@ int main()
         assert(distance(mo.begin(), mo.end()) == 0);
     }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int V;
         V ar[] =
diff --git a/test/std/containers/associative/multiset/multiset.cons/move_alloc.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/move_alloc.pass.cpp
index 4408208f2ac4..3da3fc09a45f 100644
--- a/test/std/containers/associative/multiset/multiset.cons/move_alloc.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/move_alloc.pass.cpp
@@ -163,7 +163,7 @@ int main()
 
             M m1(I(a1), I(a1+num), C(), A());
             assert(Counter_base::gConstructed == 2*num);
-        
+
             M m2(m1);
             assert(m2 == m1);
             assert(Counter_base::gConstructed == 3*num);
@@ -181,7 +181,7 @@ int main()
             }
             assert(Counter_base::gConstructed == 2*num);
         }
-        assert(Counter_base::gConstructed == 0);            
+        assert(Counter_base::gConstructed == 0);
     }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/containers/associative/multiset/multiset.cons/move_assign.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/move_assign.pass.cpp
index ca1ba971f5a4..b0ec4f39451c 100644
--- a/test/std/containers/associative/multiset/multiset.cons/move_assign.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/move_assign.pass.cpp
@@ -142,7 +142,7 @@ int main()
         assert(m1.empty());
     }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef MoveOnly V;
         typedef test_compare<std::less<MoveOnly> > C;
diff --git a/test/std/containers/associative/multiset/multiset.cons/move_assign_noexcept.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/move_assign_noexcept.pass.cpp
index 211bb36e7e95..57388637e97a 100644
--- a/test/std/containers/associative/multiset/multiset.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/move_assign_noexcept.pass.cpp
@@ -17,6 +17,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <set>
 #include <cassert>
 
@@ -28,11 +30,11 @@ struct some_comp
 {
     typedef T value_type;
     some_comp& operator=(const some_comp&);
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::multiset<MoveOnly> C;
         static_assert(std::is_nothrow_move_assignable<C>::value, "");
@@ -49,5 +51,4 @@ int main()
         typedef std::multiset<MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/associative/multiset/multiset.cons/move_noexcept.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/move_noexcept.pass.cpp
index 31a34cbde306..e3a7beedb92b 100644
--- a/test/std/containers/associative/multiset/multiset.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/move_noexcept.pass.cpp
@@ -15,6 +15,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <set>
 #include <cassert>
 
@@ -26,11 +28,11 @@ struct some_comp
 {
     typedef T value_type;
     some_comp(const some_comp&);
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::multiset<MoveOnly> C;
         static_assert(std::is_nothrow_move_constructible<C>::value, "");
@@ -47,5 +49,4 @@ int main()
         typedef std::multiset<MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/associative/multiset/multiset.special/member_swap.pass.cpp b/test/std/containers/associative/multiset/multiset.special/member_swap.pass.cpp
index 7745ddab78c3..7036138f8439 100644
--- a/test/std/containers/associative/multiset/multiset.special/member_swap.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.special/member_swap.pass.cpp
@@ -96,7 +96,7 @@ int main()
         assert(m2 == m1_save);
     }
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef int V;
     typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
diff --git a/test/std/containers/associative/multiset/multiset.special/non_member_swap.pass.cpp b/test/std/containers/associative/multiset/multiset.special/non_member_swap.pass.cpp
index f456de7f6243..91ec4ce93a27 100644
--- a/test/std/containers/associative/multiset/multiset.special/non_member_swap.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.special/non_member_swap.pass.cpp
@@ -21,6 +21,7 @@
 int main()
 {
     typedef int V;
+    {
     typedef std::multiset<int> M;
     {
         M m1;
@@ -94,6 +95,7 @@ int main()
         assert(m1 == m2_save);
         assert(m2 == m1_save);
     }
+    }
     {
         typedef test_allocator<V> A;
         typedef test_compare<std::less<int> > C;
diff --git a/test/std/containers/associative/multiset/multiset.special/swap_noexcept.pass.cpp b/test/std/containers/associative/multiset/multiset.special/swap_noexcept.pass.cpp
index 8e2c67c9b5ec..87639943a0b5 100644
--- a/test/std/containers/associative/multiset/multiset.special/swap_noexcept.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.special/swap_noexcept.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <set>
 
 // void swap(multiset& c)
@@ -15,13 +17,14 @@
 //
 //  In C++17, the standard says that swap shall have:
 //     noexcept(allocator_traits<Allocator>::is_always_equal::value &&
-//              noexcept(swap(declval<Compare&>(), declval<Compare&>())));                 
+//              noexcept(swap(declval<Compare&>(), declval<Compare&>())));
 
 // This tests a conforming extension
 
 #include <set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "MoveOnly.h"
 #include "test_allocator.h"
 
@@ -29,23 +32,20 @@ template <class T>
 struct some_comp
 {
     typedef T value_type;
-    
+
     some_comp() {}
     some_comp(const some_comp&) {}
-    void deallocate(void*, unsigned) {}
-
-    typedef std::true_type propagate_on_container_swap;
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 template <class T>
 struct some_comp2
 {
     typedef T value_type;
-    
+
     some_comp2() {}
     some_comp2(const some_comp2&) {}
-    void deallocate(void*, unsigned) {}
-    typedef std::true_type propagate_on_container_swap;
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 #if TEST_STD_VER >= 14
@@ -57,7 +57,7 @@ template <class T>
 struct some_alloc
 {
     typedef T value_type;
-    
+
     some_alloc() {}
     some_alloc(const some_alloc&);
     void deallocate(void*, unsigned) {}
@@ -69,7 +69,7 @@ template <class T>
 struct some_alloc2
 {
     typedef T value_type;
-    
+
     some_alloc2() {}
     some_alloc2(const some_alloc2&);
     void deallocate(void*, unsigned) {}
@@ -82,7 +82,7 @@ template <class T>
 struct some_alloc3
 {
     typedef T value_type;
-    
+
     some_alloc3() {}
     some_alloc3(const some_alloc3&);
     void deallocate(void*, unsigned) {}
@@ -93,7 +93,6 @@ struct some_alloc3
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::multiset<MoveOnly> C;
         C c1, c2;
@@ -143,6 +142,4 @@ int main()
     static_assert( noexcept(swap(c1, c2)), "");
     }
 #endif
-
-#endif
 }
diff --git a/test/std/containers/associative/multiset/size.pass.cpp b/test/std/containers/associative/multiset/size.pass.cpp
index 68099b566dfd..d11975b79935 100644
--- a/test/std/containers/associative/multiset/size.pass.cpp
+++ b/test/std/containers/associative/multiset/size.pass.cpp
@@ -37,7 +37,7 @@ int main()
     m.erase(m.begin());
     assert(m.size() == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
     M m;
diff --git a/test/std/containers/associative/multiset/types.pass.cpp b/test/std/containers/associative/multiset/types.pass.cpp
index e1e3ad9100c3..b37b9b328f8f 100644
--- a/test/std/containers/associative/multiset/types.pass.cpp
+++ b/test/std/containers/associative/multiset/types.pass.cpp
@@ -50,7 +50,7 @@ int main()
     static_assert((std::is_same<C::size_type, std::size_t>::value), "");
     static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::multiset<int, std::less<int>, min_allocator<int>> C;
     static_assert((std::is_same<C::key_type, int>::value), "");
diff --git a/test/std/containers/associative/multiset/upper_bound.pass.cpp b/test/std/containers/associative/multiset/upper_bound.pass.cpp
index 7ad3d6ced3d6..7bb0c3cb41f3 100644
--- a/test/std/containers/associative/multiset/upper_bound.pass.cpp
+++ b/test/std/containers/associative/multiset/upper_bound.pass.cpp
@@ -86,7 +86,7 @@ int main()
         assert(r == next(m.begin(), 9));
     }
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef int V;
     typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
diff --git a/test/std/containers/associative/set/clear.pass.cpp b/test/std/containers/associative/set/clear.pass.cpp
index 4439ad3b1e4e..7a5bf4b14a71 100644
--- a/test/std/containers/associative/set/clear.pass.cpp
+++ b/test/std/containers/associative/set/clear.pass.cpp
@@ -39,7 +39,7 @@ int main()
         m.clear();
         assert(m.size() == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::set<int, std::less<int>, min_allocator<int>> M;
         typedef int V;
diff --git a/test/std/containers/associative/set/count.pass.cpp b/test/std/containers/associative/set/count.pass.cpp
index 32fe0b8bcee9..ddc913910b5e 100644
--- a/test/std/containers/associative/set/count.pass.cpp
+++ b/test/std/containers/associative/set/count.pass.cpp
@@ -56,7 +56,7 @@ int main()
         r = m.count(4);
         assert(r == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int V;
         typedef std::set<int, std::less<int>, min_allocator<int>> M;
diff --git a/test/std/containers/associative/set/emplace.pass.cpp b/test/std/containers/associative/set/emplace.pass.cpp
index 5ebab4d24b92..47ef455a996b 100644
--- a/test/std/containers/associative/set/emplace.pass.cpp
+++ b/test/std/containers/associative/set/emplace.pass.cpp
@@ -74,7 +74,7 @@ int main()
         assert(m.size() == 1);
         assert(*r.first == 2);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::set<int, std::less<int>, min_allocator<int>> M;
         typedef std::pair<M::iterator, bool> R;
diff --git a/test/std/containers/associative/set/emplace_hint.pass.cpp b/test/std/containers/associative/set/emplace_hint.pass.cpp
index 5fdeb4ffef3a..036f4d6dfb68 100644
--- a/test/std/containers/associative/set/emplace_hint.pass.cpp
+++ b/test/std/containers/associative/set/emplace_hint.pass.cpp
@@ -68,7 +68,7 @@ int main()
         assert(m.size() == 1);
         assert(*r == 2);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::set<int, std::less<int>, min_allocator<int>> M;
         typedef M::iterator R;
diff --git a/test/std/containers/associative/set/empty.pass.cpp b/test/std/containers/associative/set/empty.pass.cpp
index eb1080263f4f..1eaa8fc90537 100644
--- a/test/std/containers/associative/set/empty.pass.cpp
+++ b/test/std/containers/associative/set/empty.pass.cpp
@@ -29,7 +29,7 @@ int main()
     m.clear();
     assert(m.empty());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::set<int, std::less<int>, min_allocator<int>> M;
     M m;
diff --git a/test/std/containers/associative/set/equal_range.pass.cpp b/test/std/containers/associative/set/equal_range.pass.cpp
index 8a180ef49248..ed41f691a459 100644
--- a/test/std/containers/associative/set/equal_range.pass.cpp
+++ b/test/std/containers/associative/set/equal_range.pass.cpp
@@ -158,7 +158,7 @@ int main()
         assert(r.second == next(m.begin(), 8));
     }
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef int V;
     typedef std::set<int, std::less<int>, min_allocator<int>> M;
diff --git a/test/std/containers/associative/set/erase_iter.pass.cpp b/test/std/containers/associative/set/erase_iter.pass.cpp
index 36828be86f28..85be1f5b9c21 100644
--- a/test/std/containers/associative/set/erase_iter.pass.cpp
+++ b/test/std/containers/associative/set/erase_iter.pass.cpp
@@ -106,7 +106,7 @@ int main()
         assert(i == m.begin());
         assert(i == m.end());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::set<int, std::less<int>, min_allocator<int>> M;
         typedef int V;
@@ -186,7 +186,7 @@ int main()
         assert(i == m.end());
     }
 #endif
-#if __cplusplus >= 201402L
+#if TEST_STD_VER >= 14
     {
     //  This is LWG #2059
         typedef TemplateConstructor T;
diff --git a/test/std/containers/associative/set/erase_iter_iter.pass.cpp b/test/std/containers/associative/set/erase_iter_iter.pass.cpp
index 479950316655..775e6cea06fa 100644
--- a/test/std/containers/associative/set/erase_iter_iter.pass.cpp
+++ b/test/std/containers/associative/set/erase_iter_iter.pass.cpp
@@ -78,7 +78,7 @@ int main()
         assert(m.size() == 0);
         assert(i == m.end());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::set<int, std::less<int>, min_allocator<int>> M;
         typedef int V;
diff --git a/test/std/containers/associative/set/erase_key.pass.cpp b/test/std/containers/associative/set/erase_key.pass.cpp
index 9d92bd70d700..6fc15d9ccfd4 100644
--- a/test/std/containers/associative/set/erase_key.pass.cpp
+++ b/test/std/containers/associative/set/erase_key.pass.cpp
@@ -109,7 +109,7 @@ int main()
         assert(m.size() == 0);
         assert(i == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::set<int, std::less<int>, min_allocator<int>> M;
         typedef int V;
diff --git a/test/std/containers/associative/set/find.pass.cpp b/test/std/containers/associative/set/find.pass.cpp
index d08d2fb1e245..60f16fcd65d4 100644
--- a/test/std/containers/associative/set/find.pass.cpp
+++ b/test/std/containers/associative/set/find.pass.cpp
@@ -92,7 +92,7 @@ int main()
         assert(r == next(m.begin(), 8));
     }
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef int V;
     typedef std::set<int, std::less<int>, min_allocator<int>> M;
diff --git a/test/std/containers/associative/set/incomplete_type.pass.cpp b/test/std/containers/associative/set/incomplete_type.pass.cpp
new file mode 100644
index 000000000000..d3a1d6638d7e
--- /dev/null
+++ b/test/std/containers/associative/set/incomplete_type.pass.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <set>
+
+// Check that std::set and it's iterators can be instantiated with an incomplete
+// type.
+
+#include <set>
+
+struct A {
+    typedef std::set<A> Set;
+    int data;
+    Set m;
+    Set::iterator it;
+    Set::const_iterator cit;
+};
+
+inline bool operator==(A const& L, A const& R) { return &L == &R; }
+inline bool operator<(A const& L, A const& R)  { return L.data < R.data; }
+int main() {
+    A a;
+}
diff --git a/test/std/containers/associative/set/insert_and_emplace_allocator_requirements.pass.cpp b/test/std/containers/associative/set/insert_and_emplace_allocator_requirements.pass.cpp
new file mode 100644
index 000000000000..b14340b1d763
--- /dev/null
+++ b/test/std/containers/associative/set/insert_and_emplace_allocator_requirements.pass.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <set>
+
+// class set
+
+// insert(...)
+// emplace(...)
+// emplace_hint(...)
+
+// UNSUPPORTED: c++98, c++03
+
+#include <set>
+#include "container_test_types.h"
+#include "../../set_allocator_requirement_test_templates.h"
+
+int main()
+{
+  testSetInsert<TCT::set<> >();
+  testSetEmplace<TCT::set<> >();
+  testSetEmplaceHint<TCT::set<> >();
+}
diff --git a/test/std/containers/associative/set/insert_cv.pass.cpp b/test/std/containers/associative/set/insert_cv.pass.cpp
index 18d5c2e03395..8d5290a97af9 100644
--- a/test/std/containers/associative/set/insert_cv.pass.cpp
+++ b/test/std/containers/associative/set/insert_cv.pass.cpp
@@ -48,7 +48,7 @@ int main()
         assert(m.size() == 3);
         assert(*r.first == 3);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::set<int, std::less<int>, min_allocator<int>> M;
         typedef std::pair<M::iterator, bool> R;
diff --git a/test/std/containers/associative/set/insert_initializer_list.pass.cpp b/test/std/containers/associative/set/insert_initializer_list.pass.cpp
index fc6d612b2ebe..60a6e754e17e 100644
--- a/test/std/containers/associative/set/insert_initializer_list.pass.cpp
+++ b/test/std/containers/associative/set/insert_initializer_list.pass.cpp
@@ -38,7 +38,7 @@ int main()
     assert(*++i == V(8));
     assert(*++i == V(10));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::set<int, std::less<int>, min_allocator<int>> C;
     typedef C::value_type V;
diff --git a/test/std/containers/associative/set/insert_iter_cv.pass.cpp b/test/std/containers/associative/set/insert_iter_cv.pass.cpp
index 718e720559f4..12d6402a87c2 100644
--- a/test/std/containers/associative/set/insert_iter_cv.pass.cpp
+++ b/test/std/containers/associative/set/insert_iter_cv.pass.cpp
@@ -44,7 +44,7 @@ int main()
         assert(m.size() == 3);
         assert(*r == 3);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::set<int, std::less<int>, min_allocator<int>> M;
         typedef M::iterator R;
diff --git a/test/std/containers/associative/set/insert_iter_iter.pass.cpp b/test/std/containers/associative/set/insert_iter_iter.pass.cpp
index ff729a0e7b9b..46edd0db0468 100644
--- a/test/std/containers/associative/set/insert_iter_iter.pass.cpp
+++ b/test/std/containers/associative/set/insert_iter_iter.pass.cpp
@@ -45,7 +45,7 @@ int main()
         assert(*next(m.begin()) == 2);
         assert(*next(m.begin(), 2) == 3);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::set<int, std::less<int>, min_allocator<int>> M;
         typedef int V;
diff --git a/test/std/containers/associative/set/insert_iter_rv.pass.cpp b/test/std/containers/associative/set/insert_iter_rv.pass.cpp
index 296ead84914d..be827d644d26 100644
--- a/test/std/containers/associative/set/insert_iter_rv.pass.cpp
+++ b/test/std/containers/associative/set/insert_iter_rv.pass.cpp
@@ -46,7 +46,7 @@ int main()
         assert(m.size() == 3);
         assert(*r == 3);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::set<MoveOnly, std::less<MoveOnly>, min_allocator<MoveOnly>> M;
         typedef M::iterator R;
diff --git a/test/std/containers/associative/set/insert_rv.pass.cpp b/test/std/containers/associative/set/insert_rv.pass.cpp
index 32cede154956..e528ef347b88 100644
--- a/test/std/containers/associative/set/insert_rv.pass.cpp
+++ b/test/std/containers/associative/set/insert_rv.pass.cpp
@@ -50,7 +50,7 @@ int main()
         assert(m.size() == 3);
         assert(*r.first == 3);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::set<MoveOnly, std::less<MoveOnly>, min_allocator<MoveOnly>> M;
         typedef std::pair<M::iterator, bool> R;
diff --git a/test/std/containers/associative/set/iterator.pass.cpp b/test/std/containers/associative/set/iterator.pass.cpp
index ecd950f03a00..c318341ce859 100644
--- a/test/std/containers/associative/set/iterator.pass.cpp
+++ b/test/std/containers/associative/set/iterator.pass.cpp
@@ -111,7 +111,7 @@ int main()
         for (int j = 1; j <= m.size(); ++j, ++i)
             assert(*i == j);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int V;
         V ar[] =
diff --git a/test/std/containers/associative/set/lower_bound.pass.cpp b/test/std/containers/associative/set/lower_bound.pass.cpp
index df202f31a4c3..55d49a097ef6 100644
--- a/test/std/containers/associative/set/lower_bound.pass.cpp
+++ b/test/std/containers/associative/set/lower_bound.pass.cpp
@@ -124,7 +124,7 @@ int main()
         assert(r == next(m.begin(), 8));
     }
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef int V;
     typedef std::set<int, std::less<int>, min_allocator<int>> M;
@@ -281,7 +281,7 @@ int main()
     r = m.lower_bound(20);
     assert(r == next(m.begin(), 8));
     }
-    
+
     {
     typedef PrivateConstructor V;
     typedef std::set<V, std::less<>> M;
diff --git a/test/std/containers/associative/set/max_size.pass.cpp b/test/std/containers/associative/set/max_size.pass.cpp
index cde4397c7178..9df6a4157e11 100644
--- a/test/std/containers/associative/set/max_size.pass.cpp
+++ b/test/std/containers/associative/set/max_size.pass.cpp
@@ -25,7 +25,7 @@ int main()
     M m;
     assert(m.max_size() != 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::set<int, std::less<int>, min_allocator<int>> M;
     M m;
diff --git a/test/std/containers/associative/set/set.cons/assign_initializer_list.pass.cpp b/test/std/containers/associative/set/set.cons/assign_initializer_list.pass.cpp
index 892ae5a0a799..70e174a59612 100644
--- a/test/std/containers/associative/set/set.cons/assign_initializer_list.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/assign_initializer_list.pass.cpp
@@ -36,7 +36,7 @@ int main()
     assert(*++i == V(5));
     assert(*++i == V(6));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::set<int, std::less<int>, min_allocator<int>> C;
     typedef C::value_type V;
diff --git a/test/std/containers/associative/set/set.cons/compare_copy_constructible.fail.cpp b/test/std/containers/associative/set/set.cons/compare_copy_constructible.fail.cpp
new file mode 100644
index 000000000000..dcf23effc443
--- /dev/null
+++ b/test/std/containers/associative/set/set.cons/compare_copy_constructible.fail.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <set>
+
+// Check that std::set fails to instantiate if the comparison predicate is 
+// not copy-constructible. This is LWG issue 2436
+
+#include <set>
+
+template <class T>
+struct Comp {
+	bool operator () (const T& lhs, const T& rhs) const { return lhs < rhs; }
+
+	Comp () {}
+private:
+	Comp (const Comp &); // declared but not defined
+	};
+
+
+int main() {
+	std::set<int, Comp<int> > m;
+}
diff --git a/test/std/containers/associative/set/set.cons/default.pass.cpp b/test/std/containers/associative/set/set.cons/default.pass.cpp
index 746a2d173071..4c924ca70e96 100644
--- a/test/std/containers/associative/set/set.cons/default.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/default.pass.cpp
@@ -25,7 +25,7 @@ int main()
     assert(m.empty());
     assert(m.begin() == m.end());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     std::set<int, std::less<int>, min_allocator<int>> m;
     assert(m.empty());
diff --git a/test/std/containers/associative/set/set.cons/default_noexcept.pass.cpp b/test/std/containers/associative/set/set.cons/default_noexcept.pass.cpp
index 2156169acbc4..6293c24a43d3 100644
--- a/test/std/containers/associative/set/set.cons/default_noexcept.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/default_noexcept.pass.cpp
@@ -17,9 +17,12 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "MoveOnly.h"
 #include "test_allocator.h"
 
@@ -28,18 +31,18 @@ struct some_comp
 {
     typedef T value_type;
     some_comp();
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::set<MoveOnly> C;
-        static_assert(std::is_nothrow_default_constructible<C>::value, "");
+        LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
     }
     {
         typedef std::set<MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C;
-        static_assert(std::is_nothrow_default_constructible<C>::value, "");
+        LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
     }
     {
         typedef std::set<MoveOnly, std::less<MoveOnly>, other_allocator<MoveOnly>> C;
@@ -49,5 +52,4 @@ int main()
         typedef std::set<MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/associative/set/set.cons/dtor_noexcept.pass.cpp b/test/std/containers/associative/set/set.cons/dtor_noexcept.pass.cpp
index b554d828d486..60d1d42c3d9c 100644
--- a/test/std/containers/associative/set/set.cons/dtor_noexcept.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/dtor_noexcept.pass.cpp
@@ -11,26 +11,24 @@
 
 // ~set() // implied noexcept;
 
+// UNSUPPORTED: c++98, c++03
+
 #include <set>
 #include <cassert>
 
 #include "MoveOnly.h"
 #include "test_allocator.h"
 
-#if __has_feature(cxx_noexcept)
-
 template <class T>
 struct some_comp
 {
     typedef T value_type;
     ~some_comp() noexcept(false);
+    bool operator()(const T&, const T&) const { return false; }
 };
 
-#endif
-
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::set<MoveOnly> C;
         static_assert(std::is_nothrow_destructible<C>::value, "");
@@ -47,5 +45,4 @@ int main()
         typedef std::set<MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/associative/set/set.cons/initializer_list.pass.cpp b/test/std/containers/associative/set/set.cons/initializer_list.pass.cpp
index 2ad538e143f8..5bb5460ddc0d 100644
--- a/test/std/containers/associative/set/set.cons/initializer_list.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/initializer_list.pass.cpp
@@ -35,7 +35,7 @@ int main()
     assert(*++i == V(5));
     assert(*++i == V(6));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::set<int, std::less<int>, min_allocator<int>> C;
     typedef C::value_type V;
diff --git a/test/std/containers/associative/set/set.cons/iter_iter.pass.cpp b/test/std/containers/associative/set/set.cons/iter_iter.pass.cpp
index 7ca7fe14d6c4..db765bd9e337 100644
--- a/test/std/containers/associative/set/set.cons/iter_iter.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/iter_iter.pass.cpp
@@ -44,7 +44,7 @@ int main()
     assert(*next(m.begin()) == 2);
     assert(*next(m.begin(), 2) == 3);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef int V;
     V ar[] =
diff --git a/test/std/containers/associative/set/set.cons/iter_iter_alloc.pass.cpp b/test/std/containers/associative/set/set.cons/iter_iter_alloc.pass.cpp
index 5ccb6e5cbcd7..077a749caaca 100644
--- a/test/std/containers/associative/set/set.cons/iter_iter_alloc.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/iter_iter_alloc.pass.cpp
@@ -28,6 +28,7 @@
 
 int main()
 {
+    {
     typedef int V;
     V ar[] =
     {
@@ -53,6 +54,7 @@ int main()
     assert(*m.begin() == 1);
     assert(*next(m.begin()) == 2);
     assert(*next(m.begin(), 2) == 3);
+    }
 #if _LIBCPP_STD_VER > 11
     {
     typedef int V;
diff --git a/test/std/containers/associative/set/set.cons/move.pass.cpp b/test/std/containers/associative/set/set.cons/move.pass.cpp
index 4026ec70c3e1..c836d4550203 100644
--- a/test/std/containers/associative/set/set.cons/move.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/move.pass.cpp
@@ -70,7 +70,7 @@ int main()
         assert(mo.size() == 0);
         assert(distance(mo.begin(), mo.end()) == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int V;
         V ar[] =
diff --git a/test/std/containers/associative/set/set.cons/move_alloc.pass.cpp b/test/std/containers/associative/set/set.cons/move_alloc.pass.cpp
index 799f0e402d63..ba2adf5bb520 100644
--- a/test/std/containers/associative/set/set.cons/move_alloc.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/move_alloc.pass.cpp
@@ -163,7 +163,7 @@ int main()
 
             M m1(I(a1), I(a1+num), C(), A());
             assert(Counter_base::gConstructed == 3+num);
-        
+
             M m2(m1);
             assert(m2 == m1);
             assert(Counter_base::gConstructed == 6+num);
@@ -181,7 +181,7 @@ int main()
             }
             assert(Counter_base::gConstructed == 3+num);
         }
-        assert(Counter_base::gConstructed == 0);            
+        assert(Counter_base::gConstructed == 0);
     }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
diff --git a/test/std/containers/associative/set/set.cons/move_assign.pass.cpp b/test/std/containers/associative/set/set.cons/move_assign.pass.cpp
index ed0e77ae1796..07cb4153fa4a 100644
--- a/test/std/containers/associative/set/set.cons/move_assign.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/move_assign.pass.cpp
@@ -141,7 +141,7 @@ int main()
         assert(m3.key_comp() == C(5));
         assert(m1.empty());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef MoveOnly V;
         typedef test_compare<std::less<MoveOnly> > C;
diff --git a/test/std/containers/associative/set/set.cons/move_assign_noexcept.pass.cpp b/test/std/containers/associative/set/set.cons/move_assign_noexcept.pass.cpp
index 3999c55e9e7c..3f7d783b7630 100644
--- a/test/std/containers/associative/set/set.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/move_assign_noexcept.pass.cpp
@@ -17,6 +17,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <set>
 #include <cassert>
 
@@ -28,11 +30,11 @@ struct some_comp
 {
     typedef T value_type;
     some_comp& operator=(const some_comp&);
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::set<MoveOnly> C;
         static_assert(std::is_nothrow_move_assignable<C>::value, "");
@@ -49,5 +51,4 @@ int main()
         typedef std::set<MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/associative/set/set.cons/move_noexcept.pass.cpp b/test/std/containers/associative/set/set.cons/move_noexcept.pass.cpp
index 5ccfed4675c5..72c2f7530a9e 100644
--- a/test/std/containers/associative/set/set.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/move_noexcept.pass.cpp
@@ -15,6 +15,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <set>
 #include <cassert>
 
@@ -26,11 +28,11 @@ struct some_comp
 {
     typedef T value_type;
     some_comp(const some_comp&);
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::set<MoveOnly> C;
         static_assert(std::is_nothrow_move_constructible<C>::value, "");
@@ -47,5 +49,4 @@ int main()
         typedef std::set<MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/associative/set/set.special/member_swap.pass.cpp b/test/std/containers/associative/set/set.special/member_swap.pass.cpp
index b5129f880afd..486d5f44291b 100644
--- a/test/std/containers/associative/set/set.special/member_swap.pass.cpp
+++ b/test/std/containers/associative/set/set.special/member_swap.pass.cpp
@@ -96,7 +96,7 @@ int main()
         assert(m2 == m1_save);
     }
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef int V;
     typedef std::set<int, std::less<int>, min_allocator<int>> M;
diff --git a/test/std/containers/associative/set/set.special/non_member_swap.pass.cpp b/test/std/containers/associative/set/set.special/non_member_swap.pass.cpp
index 0ac14464c70f..3d2d7d7d3bbc 100644
--- a/test/std/containers/associative/set/set.special/non_member_swap.pass.cpp
+++ b/test/std/containers/associative/set/set.special/non_member_swap.pass.cpp
@@ -21,6 +21,7 @@
 int main()
 {
     typedef int V;
+    {
     typedef std::set<int> M;
     {
         M m1;
@@ -94,6 +95,7 @@ int main()
         assert(m1 == m2_save);
         assert(m2 == m1_save);
     }
+    }
     {
         typedef test_allocator<V> A;
         typedef test_compare<std::less<int> > C;
diff --git a/test/std/containers/associative/set/set.special/swap_noexcept.pass.cpp b/test/std/containers/associative/set/set.special/swap_noexcept.pass.cpp
index 3ec697612754..0eb7d871b8b4 100644
--- a/test/std/containers/associative/set/set.special/swap_noexcept.pass.cpp
+++ b/test/std/containers/associative/set/set.special/swap_noexcept.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <set>
 
 // void swap(set& c)
@@ -15,13 +17,14 @@
 //
 //  In C++17, the standard says that swap shall have:
 //     noexcept(allocator_traits<Allocator>::is_always_equal::value &&
-//              noexcept(swap(declval<Compare&>(), declval<Compare&>())));                 
+//              noexcept(swap(declval<Compare&>(), declval<Compare&>())));
 
 // This tests a conforming extension
 
 #include <set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "MoveOnly.h"
 #include "test_allocator.h"
 
@@ -29,23 +32,20 @@ template <class T>
 struct some_comp
 {
     typedef T value_type;
-    
+
     some_comp() {}
     some_comp(const some_comp&) {}
-    void deallocate(void*, unsigned) {}
-
-    typedef std::true_type propagate_on_container_swap;
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 template <class T>
 struct some_comp2
 {
     typedef T value_type;
-    
+
     some_comp2() {}
     some_comp2(const some_comp2&) {}
-    void deallocate(void*, unsigned) {}
-    typedef std::true_type propagate_on_container_swap;
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 #if TEST_STD_VER >= 14
@@ -57,7 +57,7 @@ template <class T>
 struct some_alloc
 {
     typedef T value_type;
-    
+
     some_alloc() {}
     some_alloc(const some_alloc&);
     void deallocate(void*, unsigned) {}
@@ -69,7 +69,7 @@ template <class T>
 struct some_alloc2
 {
     typedef T value_type;
-    
+
     some_alloc2() {}
     some_alloc2(const some_alloc2&);
     void deallocate(void*, unsigned) {}
@@ -82,7 +82,7 @@ template <class T>
 struct some_alloc3
 {
     typedef T value_type;
-    
+
     some_alloc3() {}
     some_alloc3(const some_alloc3&);
     void deallocate(void*, unsigned) {}
@@ -93,7 +93,6 @@ struct some_alloc3
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::set<MoveOnly> C;
         C c1, c2;
@@ -144,5 +143,4 @@ int main()
     }
 #endif
 
-#endif
 }
diff --git a/test/std/containers/associative/set/size.pass.cpp b/test/std/containers/associative/set/size.pass.cpp
index e78654735508..853aeca74366 100644
--- a/test/std/containers/associative/set/size.pass.cpp
+++ b/test/std/containers/associative/set/size.pass.cpp
@@ -37,7 +37,7 @@ int main()
     m.erase(m.begin());
     assert(m.size() == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::set<int, std::less<int>, min_allocator<int>> M;
     M m;
diff --git a/test/std/containers/associative/set/types.pass.cpp b/test/std/containers/associative/set/types.pass.cpp
index 3362c42aee42..f1ce8a7c975c 100644
--- a/test/std/containers/associative/set/types.pass.cpp
+++ b/test/std/containers/associative/set/types.pass.cpp
@@ -50,7 +50,7 @@ int main()
     static_assert((std::is_same<C::size_type, std::size_t>::value), "");
     static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::set<int, std::less<int>, min_allocator<int>> C;
     static_assert((std::is_same<C::key_type, int>::value), "");
diff --git a/test/std/containers/associative/set/upper_bound.pass.cpp b/test/std/containers/associative/set/upper_bound.pass.cpp
index 10a28f064698..9d4ab2805d0d 100644
--- a/test/std/containers/associative/set/upper_bound.pass.cpp
+++ b/test/std/containers/associative/set/upper_bound.pass.cpp
@@ -124,7 +124,7 @@ int main()
         assert(r == next(m.begin(), 8));
     }
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef int V;
     typedef std::set<int, std::less<int>, min_allocator<int>> M;
@@ -281,7 +281,7 @@ int main()
     r = m.upper_bound(20);
     assert(r == next(m.begin(), 8));
     }
-    
+
     {
     typedef PrivateConstructor V;
     typedef std::set<V, std::less<>> M;
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_cont_alloc.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_cont_alloc.pass.cpp
index 66ca614126f4..dc5cca3c5568 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_cont_alloc.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_cont_alloc.pass.cpp
@@ -16,6 +16,7 @@
 #include <queue>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_allocator.h"
 
 template <class C>
@@ -41,11 +42,11 @@ struct test
         : base(comp, a) {}
     test(const value_compare& comp, const container_type& c,
         const test_allocator<int>& a) : base(comp, c, a) {}
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#if TEST_STD_VER >= 11 // testing rvalue constructor
     test(const value_compare& comp, container_type&& c,
          const test_allocator<int>& a) : base(comp, std::move(c), a) {}
     test(test&& q, const test_allocator<int>& a) : base(std::move(q), a) {}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
     test_allocator<int> get_allocator() {return c.get_allocator();}
 
     using base::c;
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_rcont_alloc.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_rcont_alloc.pass.cpp
index 643b0c625abb..a27a6e205123 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_rcont_alloc.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_rcont_alloc.pass.cpp
@@ -16,6 +16,7 @@
 #include <queue>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_allocator.h"
 
 template <class C>
@@ -41,11 +42,11 @@ struct test
         : base(comp, a) {}
     test(const value_compare& comp, const container_type& c,
         const test_allocator<int>& a) : base(comp, c, a) {}
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#if TEST_STD_VER >= 11 // testing rvalue ctor
     test(const value_compare& comp, container_type&& c,
          const test_allocator<int>& a) : base(comp, std::move(c), a) {}
     test(test&& q, const test_allocator<int>& a) : base(std::move(q), a) {}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
     test_allocator<int> get_allocator() {return c.get_allocator();}
 
     using base::c;
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/default_noexcept.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/default_noexcept.pass.cpp
index cdfa58b58554..c79feb93eb6c 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/default_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/default_noexcept.pass.cpp
@@ -15,17 +15,18 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <queue>
 #include <cassert>
 
+#include "test_macros.h"
 #include "MoveOnly.h"
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::priority_queue<MoveOnly> C;
-        static_assert(std::is_nothrow_default_constructible<C>::value, "");
+        LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/dtor_noexcept.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/dtor_noexcept.pass.cpp
index e3d071d9aad0..3cedefef2c87 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/dtor_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/dtor_noexcept.pass.cpp
@@ -11,6 +11,8 @@
 
 // ~priority_queue() // implied noexcept;
 
+// UNSUPPORTED: c++98, c++03
+
 #include <queue>
 #include <cassert>
 
@@ -18,10 +20,8 @@
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::priority_queue<MoveOnly> C;
         static_assert(std::is_nothrow_destructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/move_assign_noexcept.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/move_assign_noexcept.pass.cpp
index 590d82fe6da4..f14c3ae7ce43 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/move_assign_noexcept.pass.cpp
@@ -15,6 +15,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <queue>
 #include <cassert>
 
@@ -22,10 +24,8 @@
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::priority_queue<MoveOnly> C;
         static_assert(std::is_nothrow_move_assignable<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/move_noexcept.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/move_noexcept.pass.cpp
index 05ff253d31b4..0218992670f2 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/move_noexcept.pass.cpp
@@ -15,6 +15,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <queue>
 #include <cassert>
 
@@ -22,10 +24,8 @@
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::priority_queue<MoveOnly> C;
         static_assert(std::is_nothrow_move_constructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.special/swap_noexcept.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.special/swap_noexcept.pass.cpp
index 4d2b441c60ee..bfff607590fe 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.special/swap_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.special/swap_noexcept.pass.cpp
@@ -15,6 +15,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <queue>
 #include <cassert>
 
@@ -22,11 +24,9 @@
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::priority_queue<MoveOnly> C;
         C c1, c2;
         static_assert(noexcept(swap(c1, c2)), "");
     }
-#endif
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/types.fail.cpp b/test/std/containers/container.adaptors/priority.queue/types.fail.cpp
new file mode 100644
index 000000000000..0d3025e1739a
--- /dev/null
+++ b/test/std/containers/container.adaptors/priority.queue/types.fail.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <queue>
+
+// template <class T, class Container = vector<T>,
+//           class Compare = less<typename Container::value_type>>
+// class priority_queue
+// {
+// public:
+//     typedef Container                                container_type;
+//     typedef typename container_type::value_type      value_type;
+//     typedef typename container_type::reference       reference;
+//     typedef typename container_type::const_reference const_reference;
+//     typedef typename container_type::size_type       size_type;
+//
+// protected:
+//     container_type c;
+//     Compare comp;
+
+#include <queue>
+#include <cassert>
+#include <type_traits>
+
+int main()
+{
+//  LWG#2566 says that the first template param must match the second one's value type
+	std::priority_queue<double, std::deque<int>> t;
+}
diff --git a/test/std/containers/container.adaptors/priority.queue/types.pass.cpp b/test/std/containers/container.adaptors/priority.queue/types.pass.cpp
index ade20d47d4e3..6bc476a3ce05 100644
--- a/test/std/containers/container.adaptors/priority.queue/types.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/types.pass.cpp
@@ -15,6 +15,7 @@
 // {
 // public:
 //     typedef Container                                container_type;
+//     typedef Compare                                  value_compare; // LWG#2684
 //     typedef typename container_type::value_type      value_type;
 //     typedef typename container_type::reference       reference;
 //     typedef typename container_type::const_reference const_reference;
@@ -26,7 +27,11 @@
 
 #include <queue>
 #include <cassert>
+#include <deque>
+#include <functional>
+#include <memory>
 #include <type_traits>
+#include <vector>
 
 struct test
     : private std::priority_queue<int>
@@ -48,13 +53,16 @@ struct C
 
 int main()
 {
-    static_assert((std::is_same<std::priority_queue<int>::container_type, std::vector<int> >::value), "");
-    static_assert((std::is_same<std::priority_queue<double, std::deque<int> >::container_type, std::deque<int> >::value), "");
-    static_assert((std::is_same<std::priority_queue<double, std::deque<int> >::value_type, int>::value), "");
-    static_assert((std::is_same<std::priority_queue<int>::reference, std::vector<int>::reference>::value), "");
-    static_assert((std::is_same<std::priority_queue<int>::const_reference, std::vector<int>::const_reference>::value), "");
-    static_assert((std::is_same<std::priority_queue<int>::size_type, std::vector<int>::size_type>::value), "");
-    static_assert((std::uses_allocator<std::priority_queue<int>, std::allocator<int> >::value), "");
+    static_assert(( std::is_same<std::priority_queue<int>::container_type, std::vector<int> >::value), "");
+    static_assert(( std::is_same<std::priority_queue<int, std::deque<int> >::container_type, std::deque<int> >::value), "");
+    static_assert(( std::is_same<std::priority_queue<int, std::deque<int> >::value_type, int>::value), "");
+    static_assert(( std::is_same<std::priority_queue<int>::reference, std::vector<int>::reference>::value), "");
+    static_assert(( std::is_same<std::priority_queue<int>::const_reference, std::vector<int>::const_reference>::value), "");
+    static_assert(( std::is_same<std::priority_queue<int>::size_type, std::vector<int>::size_type>::value), "");
+    static_assert(( std::is_same<std::priority_queue<int>::value_compare, std::less<int> >::value), "");
+    static_assert(( std::is_same<std::priority_queue<int, std::deque<int> >::value_compare, std::less<int> >::value), "");
+    static_assert(( std::is_same<std::priority_queue<int, std::deque<int>, std::greater<int> >::value_compare, std::greater<int> >::value), "");
+    static_assert(( std::uses_allocator<std::priority_queue<int>, std::allocator<int> >::value), "");
     static_assert((!std::uses_allocator<std::priority_queue<int, C>, std::allocator<int> >::value), "");
     test t;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.cons/default_noexcept.pass.cpp b/test/std/containers/container.adaptors/queue/queue.cons/default_noexcept.pass.cpp
index 392853432669..43045893fe07 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons/default_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons/default_noexcept.pass.cpp
@@ -14,17 +14,18 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <queue>
 #include <cassert>
 
+#include "test_macros.h"
 #include "MoveOnly.h"
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::queue<MoveOnly> C;
-        static_assert(std::is_nothrow_default_constructible<C>::value, "");
+        LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.cons/dtor_noexcept.pass.cpp b/test/std/containers/container.adaptors/queue/queue.cons/dtor_noexcept.pass.cpp
index d9b8f731f28a..2a6783287b09 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons/dtor_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons/dtor_noexcept.pass.cpp
@@ -11,6 +11,8 @@
 
 // ~queue() // implied noexcept;
 
+// UNSUPPORTED: c++98, c++03
+
 #include <queue>
 #include <cassert>
 
@@ -18,10 +20,8 @@
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::queue<MoveOnly> C;
         static_assert(std::is_nothrow_destructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.cons/move_assign_noexcept.pass.cpp b/test/std/containers/container.adaptors/queue/queue.cons/move_assign_noexcept.pass.cpp
index beef0f12ffb7..42e1c458c9da 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons/move_assign_noexcept.pass.cpp
@@ -14,6 +14,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <queue>
 #include <cassert>
 
@@ -21,10 +23,8 @@
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::queue<MoveOnly> C;
         static_assert(std::is_nothrow_move_assignable<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.cons/move_noexcept.pass.cpp b/test/std/containers/container.adaptors/queue/queue.cons/move_noexcept.pass.cpp
index 2402e609b988..1c13b622c0a5 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons/move_noexcept.pass.cpp
@@ -14,6 +14,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <queue>
 #include <cassert>
 
@@ -21,10 +23,8 @@
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::queue<MoveOnly> C;
         static_assert(std::is_nothrow_move_constructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/types.fail.cpp b/test/std/containers/container.adaptors/queue/queue.defn/types.fail.cpp
new file mode 100644
index 000000000000..2b8341fff009
--- /dev/null
+++ b/test/std/containers/container.adaptors/queue/queue.defn/types.fail.cpp
@@ -0,0 +1,20 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <queue>
+
+#include <queue>
+#include <cassert>
+#include <type_traits>
+
+int main()
+{
+//  LWG#2566 says that the first template param must match the second one's value type
+	std::queue<double, std::deque<int>> t;
+}
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/types.pass.cpp b/test/std/containers/container.adaptors/queue/queue.defn/types.pass.cpp
index cc918a361707..7f1883a16838 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/types.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/types.pass.cpp
@@ -46,13 +46,13 @@ struct C
 
 int main()
 {
-    static_assert((std::is_same<std::queue<int>::container_type, std::deque<int> >::value), "");
-    static_assert((std::is_same<std::queue<double, std::vector<int> >::container_type, std::vector<int> >::value), "");
-    static_assert((std::is_same<std::queue<double, std::vector<int> >::value_type, int>::value), "");
-    static_assert((std::is_same<std::queue<int>::reference, std::deque<int>::reference>::value), "");
-    static_assert((std::is_same<std::queue<int>::const_reference, std::deque<int>::const_reference>::value), "");
-    static_assert((std::is_same<std::queue<int>::size_type, std::deque<int>::size_type>::value), "");
-    static_assert((std::uses_allocator<std::queue<int>, std::allocator<int> >::value), "");
+    static_assert(( std::is_same<std::queue<int>::container_type, std::deque<int> >::value), "");
+    static_assert(( std::is_same<std::queue<int, std::vector<int> >::container_type, std::vector<int> >::value), "");
+    static_assert(( std::is_same<std::queue<int, std::vector<int> >::value_type, int>::value), "");
+    static_assert(( std::is_same<std::queue<int>::reference, std::deque<int>::reference>::value), "");
+    static_assert(( std::is_same<std::queue<int>::const_reference, std::deque<int>::const_reference>::value), "");
+    static_assert(( std::is_same<std::queue<int>::size_type, std::deque<int>::size_type>::value), "");
+    static_assert(( std::uses_allocator<std::queue<int>, std::allocator<int> >::value), "");
     static_assert((!std::uses_allocator<std::queue<int, C>, std::allocator<int> >::value), "");
     test t;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.special/swap_noexcept.pass.cpp b/test/std/containers/container.adaptors/queue/queue.special/swap_noexcept.pass.cpp
index cfe4a1bb7076..e18f80a91198 100644
--- a/test/std/containers/container.adaptors/queue/queue.special/swap_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.special/swap_noexcept.pass.cpp
@@ -14,6 +14,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <queue>
 #include <cassert>
 
@@ -21,11 +23,9 @@
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::queue<MoveOnly> C;
         C c1, c2;
         static_assert(noexcept(swap(c1, c2)), "");
     }
-#endif
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.cons/default_noexcept.pass.cpp b/test/std/containers/container.adaptors/stack/stack.cons/default_noexcept.pass.cpp
index bab55863b55f..2d1f9437fc45 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons/default_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons/default_noexcept.pass.cpp
@@ -14,17 +14,18 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <stack>
 #include <cassert>
 
+#include "test_macros.h"
 #include "MoveOnly.h"
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::stack<MoveOnly> C;
-        static_assert(std::is_nothrow_default_constructible<C>::value, "");
+        LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.cons/dtor_noexcept.pass.cpp b/test/std/containers/container.adaptors/stack/stack.cons/dtor_noexcept.pass.cpp
index 477bd57a6d10..0a0111b4dc46 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons/dtor_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons/dtor_noexcept.pass.cpp
@@ -11,6 +11,8 @@
 
 // ~stack() // implied noexcept;
 
+// UNSUPPORTED: c++98, c++03
+
 #include <stack>
 #include <cassert>
 
@@ -18,10 +20,8 @@
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::stack<MoveOnly> C;
         static_assert(std::is_nothrow_destructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.cons/move_assign_noexcept.pass.cpp b/test/std/containers/container.adaptors/stack/stack.cons/move_assign_noexcept.pass.cpp
index dd836796dc17..d5822839cabf 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons/move_assign_noexcept.pass.cpp
@@ -14,6 +14,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <stack>
 #include <cassert>
 
@@ -21,10 +23,8 @@
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::stack<MoveOnly> C;
         static_assert(std::is_nothrow_move_assignable<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.cons/move_noexcept.pass.cpp b/test/std/containers/container.adaptors/stack/stack.cons/move_noexcept.pass.cpp
index cfc660b36def..7eb563c76835 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons/move_noexcept.pass.cpp
@@ -14,6 +14,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <stack>
 #include <cassert>
 
@@ -21,10 +23,8 @@
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::stack<MoveOnly> C;
         static_assert(std::is_nothrow_move_constructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.defn/types.fail.cpp b/test/std/containers/container.adaptors/stack/stack.defn/types.fail.cpp
new file mode 100644
index 000000000000..ee4c5441e7c3
--- /dev/null
+++ b/test/std/containers/container.adaptors/stack/stack.defn/types.fail.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <queue>
+
+// template <class T, class Container = vector<T>,
+//           class Compare = less<typename Container::value_type>>
+// class priority_queue
+// {
+// public:
+//     typedef Container                                container_type;
+//     typedef typename container_type::value_type      value_type;
+//     typedef typename container_type::reference       reference;
+//     typedef typename container_type::const_reference const_reference;
+//     typedef typename container_type::size_type       size_type;
+//
+// protected:
+//     container_type c;
+//     Compare comp;
+
+#include <stack>
+#include <cassert>
+#include <type_traits>
+
+int main()
+{
+//  LWG#2566 says that the first template param must match the second one's value type
+	std::stack<double, std::deque<int>> t;
+}
diff --git a/test/std/containers/container.adaptors/stack/stack.defn/types.pass.cpp b/test/std/containers/container.adaptors/stack/stack.defn/types.pass.cpp
index afc5ebd53753..77a798b8382a 100644
--- a/test/std/containers/container.adaptors/stack/stack.defn/types.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.defn/types.pass.cpp
@@ -47,13 +47,13 @@ struct C
 
 int main()
 {
-    static_assert((std::is_same<std::stack<int>::container_type, std::deque<int> >::value), "");
-    static_assert((std::is_same<std::stack<double, std::vector<int> >::container_type, std::vector<int> >::value), "");
-    static_assert((std::is_same<std::stack<double, std::vector<int> >::value_type, int>::value), "");
-    static_assert((std::is_same<std::stack<int>::reference, std::deque<int>::reference>::value), "");
-    static_assert((std::is_same<std::stack<int>::const_reference, std::deque<int>::const_reference>::value), "");
-    static_assert((std::is_same<std::stack<int>::size_type, std::deque<int>::size_type>::value), "");
-    static_assert((std::uses_allocator<std::stack<int>, std::allocator<int> >::value), "");
+    static_assert(( std::is_same<std::stack<int>::container_type, std::deque<int> >::value), "");
+    static_assert(( std::is_same<std::stack<int, std::vector<int> >::container_type, std::vector<int> >::value), "");
+    static_assert(( std::is_same<std::stack<int, std::vector<int> >::value_type, int>::value), "");
+    static_assert(( std::is_same<std::stack<int>::reference, std::deque<int>::reference>::value), "");
+    static_assert(( std::is_same<std::stack<int>::const_reference, std::deque<int>::const_reference>::value), "");
+    static_assert(( std::is_same<std::stack<int>::size_type, std::deque<int>::size_type>::value), "");
+    static_assert(( std::uses_allocator<std::stack<int>, std::allocator<int> >::value), "");
     static_assert((!std::uses_allocator<std::stack<int, C>, std::allocator<int> >::value), "");
     test t;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.special/swap_noexcept.pass.cpp b/test/std/containers/container.adaptors/stack/stack.special/swap_noexcept.pass.cpp
index 80e024f5f1e0..976e362a0483 100644
--- a/test/std/containers/container.adaptors/stack/stack.special/swap_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.special/swap_noexcept.pass.cpp
@@ -14,6 +14,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <stack>
 #include <cassert>
 
@@ -21,11 +23,9 @@
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::stack<MoveOnly> C;
         C c1, c2;
         static_assert(noexcept(swap(c1, c2)), "");
     }
-#endif
 }
diff --git a/test/std/containers/map_allocator_requirement_test_templates.h b/test/std/containers/map_allocator_requirement_test_templates.h
new file mode 100644
index 000000000000..2ae3a2e3c87a
--- /dev/null
+++ b/test/std/containers/map_allocator_requirement_test_templates.h
@@ -0,0 +1,743 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MAP_ALLOCATOR_REQUIREMENT_TEST_TEMPLATES_H
+#define MAP_ALLOCATOR_REQUIREMENT_TEST_TEMPLATES_H
+
+// <map>
+// <unordered_map>
+
+// class map
+// class unordered_map
+
+// insert(...);
+// emplace(...);
+// emplace_hint(...);
+
+// UNSUPPORTED: c++98, c++03
+
+#include <cassert>
+
+#include "test_macros.h"
+#include "count_new.hpp"
+#include "container_test_types.h"
+#include "assert_checkpoint.h"
+
+
+template <class Container>
+void testMapInsert()
+{
+  typedef typename Container::value_type ValueTp;
+  typedef typename Container::key_type Key;
+  typedef typename Container::mapped_type Mapped;
+  typedef Container C;
+  typedef std::pair<typename C::iterator, bool> R;
+  ConstructController* cc = getConstructController();
+  cc->reset();
+  {
+    CHECKPOINT("Testing C::insert(const value_type&)");
+    Container c;
+    const ValueTp v(42, 1);
+    cc->expect<const ValueTp&>();
+    assert(c.insert(v).second);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      const ValueTp v2(42, 1);
+      assert(c.insert(v2).second == false);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::insert(value_type&)");
+    Container c;
+    ValueTp v(42, 1);
+    cc->expect<const ValueTp&>();
+    assert(c.insert(v).second);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      ValueTp v2(42, 1);
+      assert(c.insert(v2).second == false);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::insert(value_type&&)");
+    Container c;
+    ValueTp v(42, 1);
+    cc->expect<ValueTp&&>();
+    assert(c.insert(std::move(v)).second);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      ValueTp v2(42, 1);
+      assert(c.insert(std::move(v2)).second == false);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::insert(const value_type&&)");
+    Container c;
+    const ValueTp v(42, 1);
+    cc->expect<const ValueTp&>();
+    assert(c.insert(std::move(v)).second);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      const ValueTp v2(42, 1);
+      assert(c.insert(std::move(v2)).second == false);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::insert({key, value})");
+    Container c;
+    cc->expect<ValueTp&&>();
+    assert(c.insert({42, 1}).second);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      const ValueTp v2(42, 1);
+      assert(c.insert(std::move(v2)).second == false);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::insert(std::initializer_list<ValueTp>)");
+    Container c;
+    std::initializer_list<ValueTp> il = { ValueTp(1, 1), ValueTp(2, 1) };
+    cc->expect<ValueTp const&>(2);
+    c.insert(il);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      c.insert(il);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::insert(Iter, Iter) for *Iter = value_type const&");
+    Container c;
+    const ValueTp ValueList[] = { ValueTp(1, 1), ValueTp(2, 1), ValueTp(3, 1) };
+    cc->expect<ValueTp const&>(3);
+    c.insert(std::begin(ValueList), std::end(ValueList));
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      c.insert(std::begin(ValueList), std::end(ValueList));
+    }
+  }
+  {
+    CHECKPOINT("Testing C::insert(Iter, Iter) for *Iter = value_type&&");
+    Container c;
+    ValueTp ValueList[] = { ValueTp(1, 1), ValueTp(2, 1) , ValueTp(3, 1) };
+    cc->expect<ValueTp&&>(3);
+    c.insert(std::move_iterator<ValueTp*>(std::begin(ValueList)),
+             std::move_iterator<ValueTp*>(std::end(ValueList)));
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      ValueTp ValueList2[] = { ValueTp(1, 1), ValueTp(2, 1) , ValueTp(3, 1) };
+      c.insert(std::move_iterator<ValueTp*>(std::begin(ValueList2)),
+               std::move_iterator<ValueTp*>(std::end(ValueList2)));
+    }
+  }
+  {
+    CHECKPOINT("Testing C::insert(Iter, Iter) for *Iter = value_type&");
+    Container c;
+    ValueTp ValueList[] = { ValueTp(1, 1), ValueTp(2, 1) , ValueTp(3, 1) };
+    cc->expect<ValueTp const&>(3);
+    c.insert(std::begin(ValueList), std::end(ValueList));
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      c.insert(std::begin(ValueList), std::end(ValueList));
+    }
+  }
+}
+
+
+template <class Container>
+void testMapInsertHint()
+{
+  typedef typename Container::value_type ValueTp;
+  typedef typename Container::key_type Key;
+  typedef typename Container::mapped_type Mapped;
+  typedef typename std::pair<Key, Mapped> NonConstKeyPair;
+  typedef Container C;
+  typedef typename C::iterator It;
+  ConstructController* cc = getConstructController();
+  cc->reset();
+  {
+    CHECKPOINT("Testing C::insert(p, const value_type&)");
+    Container c;
+    const ValueTp v(42, 1);
+    cc->expect<const ValueTp&>();
+    It ret = c.insert(c.end(), v);
+    assert(ret != c.end());
+    assert(c.size() == 1);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      const ValueTp v2(42, 1);
+      It ret2 = c.insert(c.begin(), v2);
+      assert(&(*ret2) == &(*ret));
+      assert(c.size() == 1);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::insert(p, value_type&)");
+    Container c;
+    ValueTp v(42, 1);
+    cc->expect<ValueTp const&>();
+    It ret = c.insert(c.end(), v);
+    assert(ret != c.end());
+    assert(c.size() == 1);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      ValueTp v2(42, 1);
+      It ret2 = c.insert(c.begin(), v2);
+      assert(&(*ret2) == &(*ret));
+      assert(c.size() == 1);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::insert(p, value_type&&)");
+    Container c;
+    ValueTp v(42, 1);
+    cc->expect<ValueTp&&>();
+    It ret = c.insert(c.end(), std::move(v));
+    assert(ret != c.end());
+    assert(c.size() == 1);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      ValueTp v2(42, 1);
+      It ret2 = c.insert(c.begin(), std::move(v2));
+      assert(&(*ret2) == &(*ret));
+      assert(c.size() == 1);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::insert(p, {key, value})");
+    Container c;
+    cc->expect<ValueTp&&>();
+    It ret = c.insert(c.end(), {42, 1});
+    assert(ret != c.end());
+    assert(c.size() == 1);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      It ret2 = c.insert(c.begin(), {42, 1});
+      assert(&(*ret2) == &(*ret));
+      assert(c.size() == 1);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::insert(p, const value_type&&)");
+    Container c;
+    const ValueTp v(42, 1);
+    cc->expect<const ValueTp&>();
+    It ret = c.insert(c.end(), std::move(v));
+    assert(ret != c.end());
+    assert(c.size() == 1);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      const ValueTp v2(42, 1);
+      It ret2 = c.insert(c.begin(), std::move(v2));
+      assert(&(*ret2) == &(*ret));
+      assert(c.size() == 1);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::insert(p, pair<Key, Mapped> const&)");
+    Container c;
+    const NonConstKeyPair v(42, 1);
+    cc->expect<const NonConstKeyPair&>();
+    It ret = c.insert(c.end(), v);
+    assert(ret != c.end());
+    assert(c.size() == 1);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      const NonConstKeyPair v2(42, 1);
+      It ret2 = c.insert(c.begin(), v2);
+      assert(&(*ret2) == &(*ret));
+      assert(c.size() == 1);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::insert(p, pair<Key, Mapped>&&)");
+    Container c;
+    NonConstKeyPair v(42, 1);
+    cc->expect<NonConstKeyPair&&>();
+    It ret = c.insert(c.end(), std::move(v));
+    assert(ret != c.end());
+    assert(c.size() == 1);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      NonConstKeyPair v2(42, 1);
+      It ret2 = c.insert(c.begin(), std::move(v2));
+      assert(&(*ret2) == &(*ret));
+      assert(c.size() == 1);
+    }
+  }
+
+
+}
+
+
+template <class Container>
+void testMapEmplace()
+{
+  typedef typename Container::value_type ValueTp;
+  typedef typename Container::key_type Key;
+  typedef typename Container::mapped_type Mapped;
+  typedef typename std::pair<Key, Mapped> NonConstKeyPair;
+  typedef Container C;
+  typedef std::pair<typename C::iterator, bool> R;
+  ConstructController* cc = getConstructController();
+  cc->reset();
+  {
+    CHECKPOINT("Testing C::emplace(const value_type&)");
+    Container c;
+    const ValueTp v(42, 1);
+    cc->expect<const ValueTp&>();
+    assert(c.emplace(v).second);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      const ValueTp v2(42, 1);
+      assert(c.emplace(v2).second == false);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::emplace(value_type&)");
+    Container c;
+    ValueTp v(42, 1);
+    cc->expect<ValueTp&>();
+    assert(c.emplace(v).second);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      ValueTp v2(42, 1);
+      assert(c.emplace(v2).second == false);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::emplace(value_type&&)");
+    Container c;
+    ValueTp v(42, 1);
+    cc->expect<ValueTp&&>();
+    assert(c.emplace(std::move(v)).second);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      ValueTp v2(42, 1);
+      assert(c.emplace(std::move(v2)).second == false);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::emplace(const value_type&&)");
+    Container c;
+    const ValueTp v(42, 1);
+    cc->expect<const ValueTp&&>();
+    assert(c.emplace(std::move(v)).second);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      const ValueTp v2(42, 1);
+      assert(c.emplace(std::move(v2)).second == false);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::emplace(pair<Key, Mapped> const&)");
+    Container c;
+    const NonConstKeyPair v(42, 1);
+    cc->expect<const NonConstKeyPair&>();
+    assert(c.emplace(v).second);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      const NonConstKeyPair v2(42, 1);
+      assert(c.emplace(v2).second == false);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::emplace(pair<Key, Mapped> &&)");
+    Container c;
+    NonConstKeyPair v(42, 1);
+    cc->expect<NonConstKeyPair&&>();
+    assert(c.emplace(std::move(v)).second);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      NonConstKeyPair v2(42, 1);
+      assert(c.emplace(std::move(v2)).second == false);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::emplace(const Key&, ConvertibleToMapped&&)");
+    Container c;
+    const Key k(42);
+    cc->expect<Key const&, int&&>();
+    assert(c.emplace(k, 1).second);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      const Key k2(42);
+      assert(c.emplace(k2, 2).second == false);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::emplace(Key&, Mapped&)");
+    Container c;
+    Key k(42);
+    Mapped m(1);
+    cc->expect<Key&, Mapped&>();
+    assert(c.emplace(k, m).second);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      Key k2(42);
+      assert(c.emplace(k2, m).second == false);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::emplace(Key&&, Mapped&&)");
+    Container c;
+    Key k(42);
+    Mapped m(1);
+    cc->expect<Key&&, Mapped&&>();
+    assert(c.emplace(std::move(k), std::move(m)).second);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      Key k2(42);
+      Mapped m2(2);
+      assert(c.emplace(std::move(k2), std::move(m2)).second == false);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::emplace(ConvertibleToKey&&, ConvertibleToMapped&&)");
+    Container c;
+    cc->expect<int&&, int&&>();
+    assert(c.emplace(42, 1).second);
+    assert(!cc->unchecked());
+    {
+      // test that emplacing a duplicate item allocates. We cannot optimize
+      // this case because int&& does not match the type of key exactly.
+      cc->expect<int&&, int&&>();
+      assert(c.emplace(42, 1).second == false);
+      assert(!cc->unchecked());
+    }
+  }
+}
+
+
+template <class Container>
+void testMapEmplaceHint()
+{
+  typedef typename Container::value_type ValueTp;
+  typedef typename Container::key_type Key;
+  typedef typename Container::mapped_type Mapped;
+  typedef typename std::pair<Key, Mapped> NonConstKeyPair;
+  typedef Container C;
+  typedef typename C::iterator It;
+  ConstructController* cc = getConstructController();
+  cc->reset();
+  {
+    CHECKPOINT("Testing C::emplace_hint(p, const value_type&)");
+    Container c;
+    const ValueTp v(42, 1);
+    cc->expect<const ValueTp&>();
+    It ret = c.emplace_hint(c.end(), v);
+    assert(ret != c.end());
+    assert(c.size() == 1);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      const ValueTp v2(42, 1);
+      It ret2 = c.emplace_hint(c.begin(), v2);
+      assert(&(*ret2) == &(*ret));
+      assert(c.size() == 1);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::emplace_hint(p, value_type&)");
+    Container c;
+    ValueTp v(42, 1);
+    cc->expect<ValueTp&>();
+    It ret = c.emplace_hint(c.end(), v);
+    assert(ret != c.end());
+    assert(c.size() == 1);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      ValueTp v2(42, 1);
+      It ret2 = c.emplace_hint(c.begin(), v2);
+      assert(&(*ret2) == &(*ret));
+      assert(c.size() == 1);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::emplace_hint(p, value_type&&)");
+    Container c;
+    ValueTp v(42, 1);
+    cc->expect<ValueTp&&>();
+    It ret = c.emplace_hint(c.end(), std::move(v));
+    assert(ret != c.end());
+    assert(c.size() == 1);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      ValueTp v2(42, 1);
+      It ret2 = c.emplace_hint(c.begin(), std::move(v2));
+      assert(&(*ret2) == &(*ret));
+      assert(c.size() == 1);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::emplace_hint(p, const value_type&&)");
+    Container c;
+    const ValueTp v(42, 1);
+    cc->expect<const ValueTp&&>();
+    It ret = c.emplace_hint(c.end(), std::move(v));
+    assert(ret != c.end());
+    assert(c.size() == 1);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      const ValueTp v2(42, 1);
+      It ret2 = c.emplace_hint(c.begin(), std::move(v2));
+      assert(&(*ret2) == &(*ret));
+      assert(c.size() == 1);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::emplace_hint(p, pair<Key, Mapped> const&)");
+    Container c;
+    const NonConstKeyPair v(42, 1);
+    cc->expect<const NonConstKeyPair&>();
+    It ret = c.emplace_hint(c.end(), v);
+    assert(ret != c.end());
+    assert(c.size() == 1);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      const NonConstKeyPair v2(42, 1);
+      It ret2 = c.emplace_hint(c.begin(), v2);
+      assert(&(*ret2) == &(*ret));
+      assert(c.size() == 1);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::emplace_hint(p, pair<Key, Mapped>&&)");
+    Container c;
+    NonConstKeyPair v(42, 1);
+    cc->expect<NonConstKeyPair&&>();
+    It ret = c.emplace_hint(c.end(), std::move(v));
+    assert(ret != c.end());
+    assert(c.size() == 1);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      NonConstKeyPair v2(42, 1);
+      It ret2 = c.emplace_hint(c.begin(), std::move(v2));
+      assert(&(*ret2) == &(*ret));
+      assert(c.size() == 1);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::emplace_hint(p, const Key&, ConvertibleToMapped&&)");
+    Container c;
+    const Key k(42);
+    cc->expect<Key const&, int&&>();
+    It ret = c.emplace_hint(c.end(), k, 42);
+    assert(ret != c.end());
+    assert(c.size() == 1);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      const Key k2(42);
+      It ret2 = c.emplace_hint(c.begin(), k2, 1);
+      assert(&(*ret2) == &(*ret));
+      assert(c.size() == 1);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::emplace_hint(p, Key&, Mapped&)");
+    Container c;
+    Key k(42);
+    Mapped m(1);
+    cc->expect<Key&, Mapped&>();
+    It ret = c.emplace_hint(c.end(), k, m);
+    assert(ret != c.end());
+    assert(c.size() == 1);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      Key k2(42);
+      Mapped m2(2);
+      It ret2 = c.emplace_hint(c.begin(), k2, m2);
+      assert(&(*ret2) == &(*ret));
+      assert(c.size() == 1);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::emplace_hint(p, Key&&, Mapped&&)");
+    Container c;
+    Key k(42);
+    Mapped m(1);
+    cc->expect<Key&&, Mapped&&>();
+    It ret = c.emplace_hint(c.end(), std::move(k), std::move(m));
+    assert(ret != c.end());
+    assert(c.size() == 1);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      Key k2(42);
+      Mapped m2(2);
+      It ret2 = c.emplace_hint(c.begin(), std::move(k2), std::move(m2));
+      assert(&(*ret2) == &(*ret));
+      assert(c.size() == 1);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::emplace_hint(p, ConvertibleToKey&&, ConvertibleToMapped&&)");
+    Container c;
+    cc->expect<int&&, int&&>();
+    It ret = c.emplace_hint(c.end(), 42, 1);
+    assert(ret != c.end());
+    assert(c.size() == 1);
+    assert(!cc->unchecked());
+    {
+      cc->expect<int&&, int&&>();
+      It ret2 = c.emplace_hint(c.begin(), 42, 2);
+      assert(&(*ret2) == &(*ret));
+      assert(c.size() == 1);
+      assert(!cc->unchecked());
+    }
+  }
+
+}
+
+
+template <class Container>
+void testMultimapInsert()
+{
+  typedef typename Container::value_type ValueTp;
+  typedef Container C;
+  ConstructController* cc = getConstructController();
+  cc->reset();
+  {
+    CHECKPOINT("Testing C::insert(const value_type&)");
+    Container c;
+    const ValueTp v(42, 1);
+    cc->expect<const ValueTp&>();
+    c.insert(v);
+    assert(!cc->unchecked());
+  }
+  {
+    CHECKPOINT("Testing C::insert(value_type&)");
+    Container c;
+    ValueTp v(42, 1);
+    cc->expect<ValueTp&>();
+    c.insert(v);
+    assert(!cc->unchecked());
+  }
+  {
+    CHECKPOINT("Testing C::insert(value_type&&)");
+    Container c;
+    ValueTp v(42, 1);
+    cc->expect<ValueTp&&>();
+    c.insert(std::move(v));
+    assert(!cc->unchecked());
+  }
+  {
+    CHECKPOINT("Testing C::insert({key, value})");
+    Container c;
+    cc->expect<ValueTp&&>();
+    c.insert({42, 1});
+    assert(!cc->unchecked());
+  }
+  {
+    CHECKPOINT("Testing C::insert(std::initializer_list<ValueTp>)");
+    Container c;
+    std::initializer_list<ValueTp> il = { ValueTp(1, 1), ValueTp(2, 1) };
+    cc->expect<ValueTp const&>(2);
+    c.insert(il);
+    assert(!cc->unchecked());
+  }
+  {
+    CHECKPOINT("Testing C::insert(Iter, Iter) for *Iter = value_type const&");
+    Container c;
+    const ValueTp ValueList[] = { ValueTp(1, 1), ValueTp(2, 1), ValueTp(3, 1) };
+    cc->expect<ValueTp const&>(3);
+    c.insert(std::begin(ValueList), std::end(ValueList));
+    assert(!cc->unchecked());
+  }
+  {
+    CHECKPOINT("Testing C::insert(Iter, Iter) for *Iter = value_type&&");
+    Container c;
+    ValueTp ValueList[] = { ValueTp(1, 1), ValueTp(2, 1) , ValueTp(3, 1) };
+    cc->expect<ValueTp&&>(3);
+    c.insert(std::move_iterator<ValueTp*>(std::begin(ValueList)),
+             std::move_iterator<ValueTp*>(std::end(ValueList)));
+    assert(!cc->unchecked());
+  }
+  {
+    CHECKPOINT("Testing C::insert(Iter, Iter) for *Iter = value_type&");
+    Container c;
+    ValueTp ValueList[] = { ValueTp(1, 1), ValueTp(2, 1) , ValueTp(3, 1) };
+    cc->expect<ValueTp&>(3);
+    c.insert(std::begin(ValueList), std::end(ValueList));
+    assert(!cc->unchecked());
+  }
+}
+
+
+template <class Container>
+void testMultimapInsertHint()
+{
+  typedef typename Container::value_type ValueTp;
+  typedef Container C;
+  ConstructController* cc = getConstructController();
+  cc->reset();
+  {
+    CHECKPOINT("Testing C::insert(p, const value_type&)");
+    Container c;
+    const ValueTp v(42, 1);
+    cc->expect<const ValueTp&>();
+    c.insert(c.begin(), v);
+    assert(!cc->unchecked());
+  }
+  {
+    CHECKPOINT("Testing C::insert(p, value_type&)");
+    Container c;
+    ValueTp v(42, 1);
+    cc->expect<ValueTp&>();
+    c.insert(c.begin(), v);
+    assert(!cc->unchecked());
+  }
+  {
+    CHECKPOINT("Testing C::insert(p, value_type&&)");
+    Container c;
+    ValueTp v(42, 1);
+    cc->expect<ValueTp&&>();
+    c.insert(c.begin(), std::move(v));
+    assert(!cc->unchecked());
+  }
+  {
+    CHECKPOINT("Testing C::insert(p, {key, value})");
+    Container c;
+    cc->expect<ValueTp&&>();
+    c.insert(c.begin(), {42, 1});
+    assert(!cc->unchecked());
+  }
+}
+
+#endif
diff --git a/test/std/containers/sequences/array/array.cons/initializer_list.pass.cpp b/test/std/containers/sequences/array/array.cons/initializer_list.pass.cpp
index 5e429adb6fc9..64ea75a40064 100644
--- a/test/std/containers/sequences/array/array.cons/initializer_list.pass.cpp
+++ b/test/std/containers/sequences/array/array.cons/initializer_list.pass.cpp
@@ -35,4 +35,18 @@ int main()
         C c = {};
         assert(c.size() == 0);
     }
+
+    {
+        typedef double T;
+        typedef std::array<T, 3> C;
+        C c = {1};
+        assert(c.size() == 3.0);
+        assert(c[0] == 1);
+    }
+    {
+        typedef int T;
+        typedef std::array<T, 1> C;
+        C c = {};
+        assert(c.size() == 1);
+    }
 }
diff --git a/test/std/containers/sequences/array/array.special/swap.pass.cpp b/test/std/containers/sequences/array/array.special/swap.pass.cpp
index c1b0b235ab34..413f291a2a36 100644
--- a/test/std/containers/sequences/array/array.special/swap.pass.cpp
+++ b/test/std/containers/sequences/array/array.special/swap.pass.cpp
@@ -14,10 +14,28 @@
 #include <array>
 #include <cassert>
 
+#include "test_macros.h"
 // std::array is explicitly allowed to be initialized with A a = { init-list };.
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
+struct NonSwappable {
+  NonSwappable() {}
+private:
+  NonSwappable(NonSwappable const&);
+  NonSwappable& operator=(NonSwappable const&);
+};
+
+template <class Tp>
+decltype(swap(std::declval<Tp>(), std::declval<Tp>()))
+can_swap_imp(int);
+
+template <class Tp>
+std::false_type can_swap_imp(...);
+
+template <class Tp>
+struct can_swap : std::is_same<decltype(can_swap_imp<Tp>(0)), void> {};
+
 int main()
 {
     {
@@ -44,4 +62,24 @@ int main()
         assert(c1.size() == 0);
         assert(c2.size() == 0);
     }
+    {
+        typedef NonSwappable T;
+        typedef std::array<T, 0> C0;
+        static_assert(can_swap<C0&>::value, "");
+        C0 l = {};
+        C0 r = {};
+        swap(l, r);
+#if TEST_STD_VER >= 11
+        static_assert(noexcept(swap(l, r)), "");
+#endif
+    }
+#if TEST_STD_VER >= 11
+    {
+        // NonSwappable is still considered swappable in C++03 because there
+        // is no access control SFINAE.
+        typedef NonSwappable T;
+        typedef std::array<T, 42> C1;
+        static_assert(!can_swap<C1&>::value, "");
+    }
+#endif
 }
diff --git a/test/std/containers/sequences/array/array.swap/swap.pass.cpp b/test/std/containers/sequences/array/array.swap/swap.pass.cpp
index 651798e1e790..8d01dbf959ce 100644
--- a/test/std/containers/sequences/array/array.swap/swap.pass.cpp
+++ b/test/std/containers/sequences/array/array.swap/swap.pass.cpp
@@ -10,14 +10,24 @@
 // <array>
 
 // void swap(array& a);
+// namespace std { void swap(array<T, N> &x, array<T, N> &y);
 
-#include <array>
 #include <cassert>
+#include <array>
+
+#include "test_macros.h"
 
 // std::array is explicitly allowed to be initialized with A a = { init-list };.
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
+struct NonSwappable {
+  NonSwappable() {}
+private:
+  NonSwappable(NonSwappable const&);
+  NonSwappable& operator=(NonSwappable const&);
+};
+
 int main()
 {
     {
@@ -37,6 +47,22 @@ int main()
     }
     {
         typedef double T;
+        typedef std::array<T, 3> C;
+        C c1 = {1, 2, 3.5};
+        C c2 = {4, 5, 6.5};
+        std::swap(c1, c2);
+        assert(c1.size() == 3);
+        assert(c1[0] == 4);
+        assert(c1[1] == 5);
+        assert(c1[2] == 6.5);
+        assert(c2.size() == 3);
+        assert(c2[0] == 1);
+        assert(c2[1] == 2);
+        assert(c2[2] == 3.5);
+    }
+
+    {
+        typedef double T;
         typedef std::array<T, 0> C;
         C c1 = {};
         C c2 = {};
@@ -44,4 +70,24 @@ int main()
         assert(c1.size() == 0);
         assert(c2.size() == 0);
     }
+    {
+        typedef double T;
+        typedef std::array<T, 0> C;
+        C c1 = {};
+        C c2 = {};
+        std::swap(c1, c2);
+        assert(c1.size() == 0);
+        assert(c2.size() == 0);
+    }
+    {
+        typedef NonSwappable T;
+        typedef std::array<T, 0> C0;
+        C0 l = {};
+        C0 r = {};
+        l.swap(r);
+#if TEST_STD_VER >= 11
+        static_assert(noexcept(l.swap(r)), "");
+#endif
+    }
+
 }
diff --git a/test/std/containers/sequences/array/at.pass.cpp b/test/std/containers/sequences/array/at.pass.cpp
index 5cb89dfeeb9a..9707beeb3946 100644
--- a/test/std/containers/sequences/array/at.pass.cpp
+++ b/test/std/containers/sequences/array/at.pass.cpp
@@ -49,14 +49,14 @@ int main()
         const C c = {1, 2, 3.5};
         C::const_reference r1 = c.at(0);
         assert(r1 == 1);
-        
+
         C::const_reference r2 = c.at(2);
         assert(r2 == 3.5);
 
         try { (void) c.at(3); }
         catch (const std::out_of_range &) {}
     }
-    
+
 #if TEST_STD_VER > 11
     {
         typedef double T;
diff --git a/test/std/containers/sequences/array/front_back.pass.cpp b/test/std/containers/sequences/array/front_back.pass.cpp
index bccaade986ea..7d53b8265e96 100644
--- a/test/std/containers/sequences/array/front_back.pass.cpp
+++ b/test/std/containers/sequences/array/front_back.pass.cpp
@@ -34,7 +34,7 @@ int main()
         assert(r1 == 1);
         r1 = 5.5;
         assert(c[0] == 5.5);
-        
+
         C::reference r2 = c.back();
         assert(r2 == 3.5);
         r2 = 7.5;
diff --git a/test/std/containers/sequences/array/indexing.pass.cpp b/test/std/containers/sequences/array/indexing.pass.cpp
index 5ccb0b487b95..64d2716a7592 100644
--- a/test/std/containers/sequences/array/indexing.pass.cpp
+++ b/test/std/containers/sequences/array/indexing.pass.cpp
@@ -33,7 +33,7 @@ int main()
         assert(r1 == 1);
         r1 = 5.5;
         assert(c.front() == 5.5);
-        
+
         C::reference r2 = c[2];
         assert(r2 == 3.5);
         r2 = 7.5;
diff --git a/test/std/containers/sequences/array/iterators.pass.cpp b/test/std/containers/sequences/array/iterators.pass.cpp
index 98997d8c26d5..233e9328c4ed 100644
--- a/test/std/containers/sequences/array/iterators.pass.cpp
+++ b/test/std/containers/sequences/array/iterators.pass.cpp
@@ -59,7 +59,7 @@ int main()
         assert ( c.cend()    == std::cend(c));
         assert ( c.rend()    == std::rend(c));
         assert ( c.crend()   == std::crend(c));
-        
+
         assert ( std::begin(c)   != std::end(c));
         assert ( std::rbegin(c)  != std::rend(c));
         assert ( std::cbegin(c)  != std::cend(c));
diff --git a/test/std/containers/sequences/array/types.pass.cpp b/test/std/containers/sequences/array/types.pass.cpp
index 065ade959d05..9cf390c4eacb 100644
--- a/test/std/containers/sequences/array/types.pass.cpp
+++ b/test/std/containers/sequences/array/types.pass.cpp
@@ -29,6 +29,25 @@
 #include <iterator>
 #include <type_traits>
 
+#include "test_macros.h"
+
+template <class C>
+void test_iterators() {
+    typedef std::iterator_traits<typename C::iterator> ItT;
+    typedef std::iterator_traits<typename C::const_iterator> CItT;
+    static_assert((std::is_same<typename ItT::iterator_category, std::random_access_iterator_tag>::value), "");
+    static_assert((std::is_same<typename ItT::value_type, typename C::value_type>::value), "");
+    static_assert((std::is_same<typename ItT::reference, typename C::reference>::value), "");
+    static_assert((std::is_same<typename ItT::pointer, typename C::pointer>::value), "");
+    static_assert((std::is_same<typename ItT::difference_type, typename C::difference_type>::value), "");
+
+    static_assert((std::is_same<typename CItT::iterator_category, std::random_access_iterator_tag>::value), "");
+    static_assert((std::is_same<typename CItT::value_type, typename C::value_type>::value), "");
+    static_assert((std::is_same<typename CItT::reference, typename C::const_reference>::value), "");
+    static_assert((std::is_same<typename CItT::pointer, typename C::const_pointer>::value), "");
+    static_assert((std::is_same<typename CItT::difference_type, typename C::difference_type>::value), "");
+}
+
 int main()
 {
     {
@@ -36,27 +55,43 @@ int main()
         typedef std::array<T, 10> C;
         static_assert((std::is_same<C::reference, T&>::value), "");
         static_assert((std::is_same<C::const_reference, const T&>::value), "");
-        static_assert((std::is_same<C::iterator, T*>::value), "");
-        static_assert((std::is_same<C::const_iterator, const T*>::value), "");
+        LIBCPP_STATIC_ASSERT((std::is_same<C::iterator, T*>::value), "");
+        LIBCPP_STATIC_ASSERT((std::is_same<C::const_iterator, const T*>::value), "");
+        test_iterators<C>();
         static_assert((std::is_same<C::pointer, T*>::value), "");
         static_assert((std::is_same<C::const_pointer, const T*>::value), "");
         static_assert((std::is_same<C::size_type, std::size_t>::value), "");
         static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
         static_assert((std::is_same<C::reverse_iterator, std::reverse_iterator<C::iterator> >::value), "");
         static_assert((std::is_same<C::const_reverse_iterator, std::reverse_iterator<C::const_iterator> >::value), "");
+
+        static_assert((std::is_signed<typename C::difference_type>::value), "");
+        static_assert((std::is_unsigned<typename C::size_type>::value), "");
+        static_assert((std::is_same<typename C::difference_type,
+            typename std::iterator_traits<typename C::iterator>::difference_type>::value), "");
+        static_assert((std::is_same<typename C::difference_type,
+            typename std::iterator_traits<typename C::const_iterator>::difference_type>::value), "");
     }
     {
         typedef int* T;
         typedef std::array<T, 0> C;
         static_assert((std::is_same<C::reference, T&>::value), "");
         static_assert((std::is_same<C::const_reference, const T&>::value), "");
-        static_assert((std::is_same<C::iterator, T*>::value), "");
-        static_assert((std::is_same<C::const_iterator, const T*>::value), "");
+        LIBCPP_STATIC_ASSERT((std::is_same<C::iterator, T*>::value), "");
+        LIBCPP_STATIC_ASSERT((std::is_same<C::const_iterator, const T*>::value), "");
+        test_iterators<C>();
         static_assert((std::is_same<C::pointer, T*>::value), "");
         static_assert((std::is_same<C::const_pointer, const T*>::value), "");
         static_assert((std::is_same<C::size_type, std::size_t>::value), "");
         static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
         static_assert((std::is_same<C::reverse_iterator, std::reverse_iterator<C::iterator> >::value), "");
         static_assert((std::is_same<C::const_reverse_iterator, std::reverse_iterator<C::const_iterator> >::value), "");
+
+        static_assert((std::is_signed<typename C::difference_type>::value), "");
+        static_assert((std::is_unsigned<typename C::size_type>::value), "");
+        static_assert((std::is_same<typename C::difference_type,
+            typename std::iterator_traits<typename C::iterator>::difference_type>::value), "");
+        static_assert((std::is_same<typename C::difference_type,
+            typename std::iterator_traits<typename C::const_iterator>::difference_type>::value), "");
     }
 }
diff --git a/test/std/containers/sequences/deque/deque.capacity/access.pass.cpp b/test/std/containers/sequences/deque/deque.capacity/access.pass.cpp
index 996fc9a18fe7..a6a8e7424b25 100644
--- a/test/std/containers/sequences/deque/deque.capacity/access.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.capacity/access.pass.cpp
@@ -68,7 +68,7 @@ int main()
         assert(c.front() == 0);
         assert(c.back() == 9);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::deque<int, min_allocator<int>> c = make<std::deque<int, min_allocator<int>> >(10);
         for (unsigned i = 0; i < 10; ++i)
diff --git a/test/std/containers/sequences/deque/deque.capacity/resize_size.pass.cpp b/test/std/containers/sequences/deque/deque.capacity/resize_size.pass.cpp
index 84f04f9d52da..53c6bd3380a2 100644
--- a/test/std/containers/sequences/deque/deque.capacity/resize_size.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.capacity/resize_size.pass.cpp
@@ -12,6 +12,8 @@
 // void resize(size_type n);
 
 #include <deque>
+#include <algorithm>
+#include <iterator>
 #include <cassert>
 
 #include "test_macros.h"
diff --git a/test/std/containers/sequences/deque/deque.capacity/resize_size_value.pass.cpp b/test/std/containers/sequences/deque/deque.capacity/resize_size_value.pass.cpp
index 2bf2423fb9af..12af64386bd8 100644
--- a/test/std/containers/sequences/deque/deque.capacity/resize_size_value.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.capacity/resize_size_value.pass.cpp
@@ -12,6 +12,8 @@
 // void resize(size_type n, const value_type& v);
 
 #include <deque>
+#include <algorithm>
+#include <iterator>
 #include <cassert>
 
 #include "test_macros.h"
diff --git a/test/std/containers/sequences/deque/deque.cons/alloc.pass.cpp b/test/std/containers/sequences/deque/deque.cons/alloc.pass.cpp
index 841bfd9f8a7f..787c2394b38e 100644
--- a/test/std/containers/sequences/deque/deque.cons/alloc.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/alloc.pass.cpp
@@ -31,7 +31,7 @@ int main()
 {
     test<int>(std::allocator<int>());
     test<NotConstructible>(test_allocator<NotConstructible>(3));
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test<int>(min_allocator<int>());
     test<NotConstructible>(min_allocator<NotConstructible>{});
 #endif
diff --git a/test/std/containers/sequences/deque/deque.cons/assign_initializer_list.pass.cpp b/test/std/containers/sequences/deque/deque.cons/assign_initializer_list.pass.cpp
index c760b4372444..dea6492a515d 100644
--- a/test/std/containers/sequences/deque/deque.cons/assign_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/assign_initializer_list.pass.cpp
@@ -28,7 +28,7 @@ int main()
     assert(d[2] == 5);
     assert(d[3] == 6);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     std::deque<int, min_allocator<int>> d;
     d.assign({3, 4, 5, 6});
diff --git a/test/std/containers/sequences/deque/deque.cons/copy.pass.cpp b/test/std/containers/sequences/deque/deque.cons/copy.pass.cpp
index fa0c1203ede9..ec73555b9c4f 100644
--- a/test/std/containers/sequences/deque/deque.cons/copy.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/copy.pass.cpp
@@ -45,7 +45,7 @@ int main()
         assert(v2.get_allocator() == other_allocator<int>(-2));
     }
 #endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
         int* an = ab + sizeof(ab)/sizeof(ab[0]);
diff --git a/test/std/containers/sequences/deque/deque.cons/copy_alloc.pass.cpp b/test/std/containers/sequences/deque/deque.cons/copy_alloc.pass.cpp
index efea4948eba1..3a49a8bc0c66 100644
--- a/test/std/containers/sequences/deque/deque.cons/copy_alloc.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/copy_alloc.pass.cpp
@@ -40,7 +40,7 @@ int main()
         test(std::deque<int, other_allocator<int> >(ab, an, other_allocator<int>(3)),
                                                             other_allocator<int>(4));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
         int* an = ab + sizeof(ab)/sizeof(ab[0]);
diff --git a/test/std/containers/sequences/deque/deque.cons/default.pass.cpp b/test/std/containers/sequences/deque/deque.cons/default.pass.cpp
index b725dade70b2..7c42d9e7786e 100644
--- a/test/std/containers/sequences/deque/deque.cons/default.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/default.pass.cpp
@@ -24,7 +24,7 @@ test()
 {
     std::deque<T, Allocator> d;
     assert(d.size() == 0);
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     std::deque<T, Allocator> d1 = {};
     assert(d1.size() == 0);
 #endif
@@ -34,7 +34,7 @@ int main()
 {
     test<int, std::allocator<int> >();
     test<NotConstructible, stack_allocator<NotConstructible, 1> >();
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test<int, min_allocator<int> >();
     test<NotConstructible, min_allocator<NotConstructible> >();
 #endif
diff --git a/test/std/containers/sequences/deque/deque.cons/default_noexcept.pass.cpp b/test/std/containers/sequences/deque/deque.cons/default_noexcept.pass.cpp
index c612dbc5e838..30cca929da11 100644
--- a/test/std/containers/sequences/deque/deque.cons/default_noexcept.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/default_noexcept.pass.cpp
@@ -14,9 +14,12 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <deque>
 #include <cassert>
 
+#include "test_macros.h"
 #include "MoveOnly.h"
 #include "test_allocator.h"
 
@@ -29,14 +32,13 @@ struct some_alloc
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::deque<MoveOnly> C;
-        static_assert(std::is_nothrow_default_constructible<C>::value, "");
+        LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
     }
     {
         typedef std::deque<MoveOnly, test_allocator<MoveOnly>> C;
-        static_assert(std::is_nothrow_default_constructible<C>::value, "");
+        LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
     }
     {
         typedef std::deque<MoveOnly, other_allocator<MoveOnly>> C;
@@ -46,5 +48,4 @@ int main()
         typedef std::deque<MoveOnly, some_alloc<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/sequences/deque/deque.cons/dtor_noexcept.pass.cpp b/test/std/containers/sequences/deque/deque.cons/dtor_noexcept.pass.cpp
index ecdc2404c855..503e1237e9eb 100644
--- a/test/std/containers/sequences/deque/deque.cons/dtor_noexcept.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/dtor_noexcept.pass.cpp
@@ -11,14 +11,14 @@
 
 // ~deque() // implied noexcept;
 
+// UNSUPPORTED: c++98, c++03
+
 #include <deque>
 #include <cassert>
 
 #include "MoveOnly.h"
 #include "test_allocator.h"
 
-#if __has_feature(cxx_noexcept)
-
 template <class T>
 struct some_alloc
 {
@@ -27,11 +27,8 @@ struct some_alloc
     ~some_alloc() noexcept(false);
 };
 
-#endif
-
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::deque<MoveOnly> C;
         static_assert(std::is_nothrow_destructible<C>::value, "");
@@ -48,5 +45,4 @@ int main()
         typedef std::deque<MoveOnly, some_alloc<MoveOnly>> C;
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/sequences/deque/deque.cons/initializer_list.pass.cpp b/test/std/containers/sequences/deque/deque.cons/initializer_list.pass.cpp
index a9e0218e2e0b..dbf27053a9f9 100644
--- a/test/std/containers/sequences/deque/deque.cons/initializer_list.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/initializer_list.pass.cpp
@@ -27,7 +27,7 @@ int main()
     assert(d[2] == 5);
     assert(d[3] == 6);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     std::deque<int, min_allocator<int>> d = {3, 4, 5, 6};
     assert(d.size() == 4);
diff --git a/test/std/containers/sequences/deque/deque.cons/initializer_list_alloc.pass.cpp b/test/std/containers/sequences/deque/deque.cons/initializer_list_alloc.pass.cpp
index 36c5af60ee34..9be3c63a6b31 100644
--- a/test/std/containers/sequences/deque/deque.cons/initializer_list_alloc.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/initializer_list_alloc.pass.cpp
@@ -29,7 +29,7 @@ int main()
     assert(d[2] == 5);
     assert(d[3] == 6);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     std::deque<int, min_allocator<int>> d({3, 4, 5, 6}, min_allocator<int>());
     assert(d.get_allocator() == min_allocator<int>());
diff --git a/test/std/containers/sequences/deque/deque.cons/iter_iter.pass.cpp b/test/std/containers/sequences/deque/deque.cons/iter_iter.pass.cpp
index faadf2b1a1db..12a7faf686db 100644
--- a/test/std/containers/sequences/deque/deque.cons/iter_iter.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/iter_iter.pass.cpp
@@ -56,7 +56,7 @@ int main()
     test(bidirectional_iterator<const int*>(ab), bidirectional_iterator<const int*>(an));
     test(random_access_iterator<const int*>(ab), random_access_iterator<const int*>(an));
     test<stack_allocator<int, 4096> >(ab, an);
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test<min_allocator<int> >(ab, an);
 #endif
 }
diff --git a/test/std/containers/sequences/deque/deque.cons/iter_iter_alloc.pass.cpp b/test/std/containers/sequences/deque/deque.cons/iter_iter_alloc.pass.cpp
index b8c3e889929d..c8f7759a19d6 100644
--- a/test/std/containers/sequences/deque/deque.cons/iter_iter_alloc.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/iter_iter_alloc.pass.cpp
@@ -42,7 +42,7 @@ int main()
     test(forward_iterator<const int*>(ab), forward_iterator<const int*>(an), test_allocator<int>(4));
     test(bidirectional_iterator<const int*>(ab), bidirectional_iterator<const int*>(an), test_allocator<int>(5));
     test(random_access_iterator<const int*>(ab), random_access_iterator<const int*>(an), test_allocator<int>(6));
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test(input_iterator<const int*>(ab), input_iterator<const int*>(an), min_allocator<int>());
     test(forward_iterator<const int*>(ab), forward_iterator<const int*>(an), min_allocator<int>());
     test(bidirectional_iterator<const int*>(ab), bidirectional_iterator<const int*>(an), min_allocator<int>());
diff --git a/test/std/containers/sequences/deque/deque.cons/move.pass.cpp b/test/std/containers/sequences/deque/deque.cons/move.pass.cpp
index 4a7aa8a058eb..68875139da1a 100644
--- a/test/std/containers/sequences/deque/deque.cons/move.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/move.pass.cpp
@@ -51,7 +51,7 @@ int main()
         assert(c1.size() == 0);
         assert(c3.get_allocator() == c1.get_allocator());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
         int* an = ab + sizeof(ab)/sizeof(ab[0]);
diff --git a/test/std/containers/sequences/deque/deque.cons/move_alloc.pass.cpp b/test/std/containers/sequences/deque/deque.cons/move_alloc.pass.cpp
index 1a5db6db6500..4aa0fa6827e7 100644
--- a/test/std/containers/sequences/deque/deque.cons/move_alloc.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/move_alloc.pass.cpp
@@ -66,7 +66,7 @@ int main()
         assert(c3.get_allocator() == A(3));
         assert(c1.size() != 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
         int* an = ab + sizeof(ab)/sizeof(ab[0]);
diff --git a/test/std/containers/sequences/deque/deque.cons/move_assign.pass.cpp b/test/std/containers/sequences/deque/deque.cons/move_assign.pass.cpp
index e50cd8ed508d..ed8f1544bc8f 100644
--- a/test/std/containers/sequences/deque/deque.cons/move_assign.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/move_assign.pass.cpp
@@ -69,7 +69,7 @@ int main()
         assert(c1.size() == 0);
         assert(c3.get_allocator() == A(5));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
         int* an = ab + sizeof(ab)/sizeof(ab[0]);
diff --git a/test/std/containers/sequences/deque/deque.cons/move_assign_noexcept.pass.cpp b/test/std/containers/sequences/deque/deque.cons/move_assign_noexcept.pass.cpp
index 24180b5b5bdd..cebf76a15a4a 100644
--- a/test/std/containers/sequences/deque/deque.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/move_assign_noexcept.pass.cpp
@@ -16,6 +16,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <deque>
 #include <cassert>
 
@@ -31,7 +33,6 @@ struct some_alloc
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::deque<MoveOnly> C;
         static_assert(std::is_nothrow_move_assignable<C>::value, "");
@@ -48,5 +49,4 @@ int main()
         typedef std::deque<MoveOnly, some_alloc<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/sequences/deque/deque.cons/move_noexcept.pass.cpp b/test/std/containers/sequences/deque/deque.cons/move_noexcept.pass.cpp
index 0ea0431be8e2..f53e1ba6c807 100644
--- a/test/std/containers/sequences/deque/deque.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/move_noexcept.pass.cpp
@@ -14,6 +14,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <deque>
 #include <cassert>
 
@@ -29,7 +31,6 @@ struct some_alloc
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::deque<MoveOnly> C;
         static_assert(std::is_nothrow_move_constructible<C>::value, "");
@@ -46,5 +47,4 @@ int main()
         typedef std::deque<MoveOnly, some_alloc<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/sequences/deque/deque.cons/op_equal.pass.cpp b/test/std/containers/sequences/deque/deque.cons/op_equal.pass.cpp
index 3a6ec8370b84..6aac6b20c49e 100644
--- a/test/std/containers/sequences/deque/deque.cons/op_equal.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/op_equal.pass.cpp
@@ -46,7 +46,7 @@ int main()
         assert(l2 == l);
         assert(l2.get_allocator() == other_allocator<int>(5));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
         int* an = ab + sizeof(ab)/sizeof(ab[0]);
diff --git a/test/std/containers/sequences/deque/deque.cons/op_equal_initializer_list.pass.cpp b/test/std/containers/sequences/deque/deque.cons/op_equal_initializer_list.pass.cpp
index 6468e4329bda..597f642db3ce 100644
--- a/test/std/containers/sequences/deque/deque.cons/op_equal_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/op_equal_initializer_list.pass.cpp
@@ -28,7 +28,7 @@ int main()
     assert(d[2] == 5);
     assert(d[3] == 6);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     std::deque<int, min_allocator<int>> d;
     d = {3, 4, 5, 6};
diff --git a/test/std/containers/sequences/deque/deque.cons/size.pass.cpp b/test/std/containers/sequences/deque/deque.cons/size.pass.cpp
index d2e324b0e3f5..b3fccf6671c9 100644
--- a/test/std/containers/sequences/deque/deque.cons/size.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/size.pass.cpp
@@ -100,7 +100,7 @@ int main()
 
     test1<DefaultOnly, stack_allocator<DefaultOnly, 4096> >(4095);
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test<DefaultOnly, min_allocator<DefaultOnly> >(4095);
 #endif
 
diff --git a/test/std/containers/sequences/deque/deque.cons/size_value.pass.cpp b/test/std/containers/sequences/deque/deque.cons/size_value.pass.cpp
index 859deba1e1ae..aeda168d19d4 100644
--- a/test/std/containers/sequences/deque/deque.cons/size_value.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/size_value.pass.cpp
@@ -45,7 +45,7 @@ int main()
     test<int, std::allocator<int> >(4096, 1165);
     test<int, std::allocator<int> >(4097, 157);
     test<int, stack_allocator<int, 4096> >(4095, 90);
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test<int, min_allocator<int> >(4095, 90);
 #endif
 }
diff --git a/test/std/containers/sequences/deque/deque.cons/size_value_alloc.pass.cpp b/test/std/containers/sequences/deque/deque.cons/size_value_alloc.pass.cpp
index 5693be702de7..ed8a7e13baa5 100644
--- a/test/std/containers/sequences/deque/deque.cons/size_value_alloc.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/size_value_alloc.pass.cpp
@@ -47,7 +47,7 @@ int main()
     test(4096, 1165, a);
     test(4097, 157, a);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     min_allocator<int> a;
     test(0, 5, a);
diff --git a/test/std/containers/sequences/deque/deque.modifiers/emplace_back.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/emplace_back.pass.cpp
index cf717c2e2f27..784b3a38553a 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/emplace_back.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/emplace_back.pass.cpp
@@ -16,6 +16,7 @@
 
 #include "../../../Emplaceable.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
@@ -74,7 +75,7 @@ int main()
         for (int j = 0; j < N; ++j)
             testN<std::deque<Emplaceable> >(rng[i], rng[j]);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
@@ -82,6 +83,17 @@ int main()
         for (int j = 0; j < N; ++j)
             testN<std::deque<Emplaceable, min_allocator<Emplaceable>> >(rng[i], rng[j]);
     }
+    {
+        std::deque<Tag_X, TaggingAllocator<Tag_X>> c;
+        c.emplace_back();
+        assert(c.size() == 1);
+        c.emplace_back(1, 2, 3);
+        assert(c.size() == 2);
+        c.emplace_front();
+        assert(c.size() == 3);
+        c.emplace_front(1, 2, 3);
+        assert(c.size() == 4);
+    }
 #endif
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/containers/sequences/deque/deque.modifiers/emplace_front.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/emplace_front.pass.cpp
index becf94ffb4ef..afc0e4972e38 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/emplace_front.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/emplace_front.pass.cpp
@@ -74,7 +74,7 @@ int main()
         for (int j = 0; j < N; ++j)
             testN<std::deque<Emplaceable> >(rng[i], rng[j]);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
diff --git a/test/std/containers/sequences/deque/deque.modifiers/erase_iter.invalidation.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/erase_iter.invalidation.pass.cpp
index 49465cddaef7..a7a93571f509 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/erase_iter.invalidation.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/erase_iter.invalidation.pass.cpp
@@ -23,9 +23,9 @@ void del_at_start(C c)
     typename C::iterator first = c.begin();
     typename C::iterator it1 = first + 1;
     typename C::iterator it2 = c.end() - 1;
-    
+
     c.erase (first);
-    
+
     typename C::iterator it3 = c.begin();
     typename C::iterator it4 = c.end() - 1;
     assert(  it1 ==   it3);
@@ -42,7 +42,7 @@ void del_at_end(C c)
     typename C::iterator first = c.end() - 1;
     typename C::iterator it1 = c.begin();
     typename C::iterator it2 = first - 1;
-    
+
     c.erase (first);
 
     typename C::iterator it3 = c.begin();
@@ -60,7 +60,7 @@ int main()
     std::deque<int> queue;
     for (int i = 0; i < 20; ++i)
         queue.push_back(i);
-    
+
     while (queue.size() > 1)
     {
         del_at_start(queue);
diff --git a/test/std/containers/sequences/deque/deque.modifiers/erase_iter.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/erase_iter.pass.cpp
index a45b75d25c9c..116ed9aa4b5a 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/erase_iter.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/erase_iter.pass.cpp
@@ -12,6 +12,8 @@
 // iterator erase(const_iterator p)
 
 #include <deque>
+#include <algorithm>
+#include <iterator>
 #include <cassert>
 
 #include "min_allocator.h"
@@ -78,7 +80,7 @@ int main()
         for (int j = 0; j < N; ++j)
             testN<std::deque<int> >(rng[i], rng[j]);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
diff --git a/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.invalidation.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.invalidation.pass.cpp
index c785e264db06..a0ccd200bfb7 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.invalidation.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.invalidation.pass.cpp
@@ -26,9 +26,9 @@ void del_at_start(C c, size_t num)
     typename C::iterator last  = first + num;
     typename C::iterator it1 = last;
     typename C::iterator it2 = c.end() - 1;
-    
+
     c.erase (first, last);
-    
+
     typename C::iterator it3 = c.begin();
     typename C::iterator it4 = c.end() - 1;
     assert(  it1 ==   it3);
@@ -38,7 +38,7 @@ void del_at_start(C c, size_t num)
     assert( *it2 ==  *it4);
     assert(&*it2 == &*it4);
 }
-    
+
 template <typename C>
 void del_at_end(C c, size_t num)
 {
@@ -46,7 +46,7 @@ void del_at_end(C c, size_t num)
     typename C::iterator first = last - num;
     typename C::iterator it1 = c.begin();
     typename C::iterator it2 = first - 1;
-    
+
     c.erase (first, last);
 
     typename C::iterator it3 = c.begin();
diff --git a/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.pass.cpp
index 0576aca5c1a8..a53abaf85d33 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.pass.cpp
@@ -14,6 +14,8 @@
 // iterator erase(const_iterator f, const_iterator l)
 
 #include <deque>
+#include <algorithm>
+#include <iterator>
 #include <cassert>
 
 #include "min_allocator.h"
@@ -84,7 +86,7 @@ int main()
         for (int j = 0; j < N; ++j)
             testN<std::deque<int> >(rng[i], rng[j]);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
diff --git a/test/std/containers/sequences/deque/deque.modifiers/pop_back.invalidation.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/pop_back.invalidation.pass.cpp
index 1d84f73ccb56..0f5f8e67a24b 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/pop_back.invalidation.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/pop_back.invalidation.pass.cpp
@@ -22,9 +22,9 @@ void test(C c)
 {
     typename C::iterator it1 = c.begin();
     typename C::iterator it2 = c.end() - 2;
-    
+
     c.pop_back();
-    
+
     typename C::iterator it3 = c.begin();
     typename C::iterator it4 = c.end() - 1;
     assert(  it1 ==   it3);
@@ -40,7 +40,7 @@ int main()
     std::deque<int> queue;
     for (int i = 0; i < 20; ++i)
         queue.push_back(i);
-    
+
     while (queue.size() > 1)
     {
         test(queue);
diff --git a/test/std/containers/sequences/deque/deque.modifiers/pop_back.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/pop_back.pass.cpp
index b345faaf89e9..aeb62c9d996a 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/pop_back.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/pop_back.pass.cpp
@@ -72,7 +72,7 @@ int main()
         for (int j = 0; j < N; ++j)
             testN<std::deque<int> >(rng[i], rng[j]);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
diff --git a/test/std/containers/sequences/deque/deque.modifiers/pop_front.invalidation.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/pop_front.invalidation.pass.cpp
index 78317f3a3f9c..d7fd910cca5f 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/pop_front.invalidation.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/pop_front.invalidation.pass.cpp
@@ -22,9 +22,9 @@ void test(C c)
 {
     typename C::iterator it1 = c.begin() + 1;
     typename C::iterator it2 = c.end() - 1;
-    
+
     c.pop_front();
-    
+
     typename C::iterator it3 = c.begin();
     typename C::iterator it4 = c.end() - 1;
     assert(  it1 ==   it3);
@@ -40,7 +40,7 @@ int main()
     std::deque<int> queue;
     for (int i = 0; i < 20; ++i)
         queue.push_back(i);
-    
+
     while (queue.size() > 1)
     {
         test(queue);
diff --git a/test/std/containers/sequences/deque/deque.modifiers/pop_front.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/pop_front.pass.cpp
index d570ec333715..c7a3a625eab6 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/pop_front.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/pop_front.pass.cpp
@@ -72,7 +72,7 @@ int main()
         for (int j = 0; j < N; ++j)
             testN<std::deque<int> >(rng[i], rng[j]);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
diff --git a/test/std/containers/sequences/deque/deque.modifiers/push_back.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/push_back.pass.cpp
index 96df6097d994..198cbcf67cc7 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/push_back.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/push_back.pass.cpp
@@ -62,7 +62,7 @@ int main()
     for (int j = 0; j < N; ++j)
         test<std::deque<int> >(rng[j]);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2046, 2047, 2048, 2049, 4094, 4095, 4096};
     const int N = sizeof(rng)/sizeof(rng[0]);
diff --git a/test/std/containers/sequences/deque/deque.modifiers/push_back_exception_safety.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/push_back_exception_safety.pass.cpp
index b37e961e442f..1fe1da102f37 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/push_back_exception_safety.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/push_back_exception_safety.pass.cpp
@@ -26,11 +26,11 @@ class CMyClass {
 
     bool equal(const CMyClass &rhs) const
         { return fTag == rhs.fTag && fMagicValue == rhs.fMagicValue; }
-        
+
     private:
         int fMagicValue;
         int fTag;
-        
+
     private: static int kStartedConstructionMagicValue;
     private: static int kFinishedConstructionMagicValue;
 };
@@ -84,7 +84,7 @@ int main()
         assert(vec==vec2);
     }
 	}
-	
+
 	{
 	typedef std::deque<CMyClass, test_allocator<CMyClass> > C;
     C vec;
diff --git a/test/std/containers/sequences/deque/deque.modifiers/push_back_rvalue.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/push_back_rvalue.pass.cpp
index d4ab0d3e2f26..b5c881064a95 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/push_back_rvalue.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/push_back_rvalue.pass.cpp
@@ -68,7 +68,7 @@ int main()
     for (int j = 0; j < N; ++j)
         test<std::deque<MoveOnly> >(rng[j]);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2046, 2047, 2048, 2049, 4094, 4095, 4096};
     const int N = sizeof(rng)/sizeof(rng[0]);
diff --git a/test/std/containers/sequences/deque/deque.modifiers/push_front.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/push_front.pass.cpp
index 4d6443b1f967..ee4f3d7f9ed7 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/push_front.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/push_front.pass.cpp
@@ -71,7 +71,7 @@ int main()
         for (int j = 0; j < N; ++j)
             testN<std::deque<int> >(rng[i], rng[j]);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
    {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
diff --git a/test/std/containers/sequences/deque/deque.modifiers/push_front_exception_safety.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/push_front_exception_safety.pass.cpp
index b4caa947aed8..7464870f07e1 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/push_front_exception_safety.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/push_front_exception_safety.pass.cpp
@@ -30,7 +30,7 @@ class CMyClass {
     private:
         int fMagicValue;
         int fTag;
-        
+
     private: static int kStartedConstructionMagicValue;
     private: static int kFinishedConstructionMagicValue;
 };
@@ -84,7 +84,7 @@ int main()
         assert(vec==vec2);
     }
 	}
-	
+
 	{
 	typedef std::deque<CMyClass, test_allocator<CMyClass> > C;
     C vec;
diff --git a/test/std/containers/sequences/deque/deque.modifiers/push_front_rvalue.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/push_front_rvalue.pass.cpp
index ea91ec1b0a44..ab15ca3326bf 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/push_front_rvalue.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/push_front_rvalue.pass.cpp
@@ -77,7 +77,7 @@ int main()
         for (int j = 0; j < N; ++j)
             testN<std::deque<MoveOnly> >(rng[i], rng[j]);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
diff --git a/test/std/containers/sequences/deque/deque.special/copy.pass.cpp b/test/std/containers/sequences/deque/deque.special/copy.pass.cpp
index 3a9962b330a4..846d87c6b664 100644
--- a/test/std/containers/sequences/deque/deque.special/copy.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.special/copy.pass.cpp
@@ -76,7 +76,7 @@ int main()
         for (int j = 0; j < N; ++j)
             testN<std::deque<int> >(rng[i], rng[j]);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
diff --git a/test/std/containers/sequences/deque/deque.special/copy_backward.pass.cpp b/test/std/containers/sequences/deque/deque.special/copy_backward.pass.cpp
index ccb30a9997d8..e7f37f98d270 100644
--- a/test/std/containers/sequences/deque/deque.special/copy_backward.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.special/copy_backward.pass.cpp
@@ -75,7 +75,7 @@ int main()
         for (int j = 0; j < N; ++j)
             testN<std::deque<int> >(rng[i], rng[j]);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
diff --git a/test/std/containers/sequences/deque/deque.special/move.pass.cpp b/test/std/containers/sequences/deque/deque.special/move.pass.cpp
index abd8e079975a..1bdbeaf9d5c6 100644
--- a/test/std/containers/sequences/deque/deque.special/move.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.special/move.pass.cpp
@@ -75,7 +75,7 @@ int main()
         for (int j = 0; j < N; ++j)
             testN<std::deque<int> >(rng[i], rng[j]);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
diff --git a/test/std/containers/sequences/deque/deque.special/move_backward.pass.cpp b/test/std/containers/sequences/deque/deque.special/move_backward.pass.cpp
index ea04f6a15acf..8e909c63c912 100644
--- a/test/std/containers/sequences/deque/deque.special/move_backward.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.special/move_backward.pass.cpp
@@ -75,7 +75,7 @@ int main()
         for (int j = 0; j < N; ++j)
             testN<std::deque<int> >(rng[i], rng[j]);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
diff --git a/test/std/containers/sequences/deque/deque.special/swap.pass.cpp b/test/std/containers/sequences/deque/deque.special/swap.pass.cpp
index 26757c351f1a..ab21f434937e 100644
--- a/test/std/containers/sequences/deque/deque.special/swap.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.special/swap.pass.cpp
@@ -85,7 +85,7 @@ int main()
         assert((c2 == std::deque<int, A>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
         assert(c2.get_allocator() == A(1));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
         const int N = sizeof(rng)/sizeof(rng[0]);
diff --git a/test/std/containers/sequences/deque/deque.special/swap_noexcept.pass.cpp b/test/std/containers/sequences/deque/deque.special/swap_noexcept.pass.cpp
index 83bcac8997ed..2f999e9a7a5d 100644
--- a/test/std/containers/sequences/deque/deque.special/swap_noexcept.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.special/swap_noexcept.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <deque>
 
 // void swap(deque& c)
@@ -21,6 +23,7 @@
 #include <deque>
 #include <cassert>
 
+#include "test_macros.h"
 #include "MoveOnly.h"
 #include "test_allocator.h"
 
@@ -28,7 +31,7 @@ template <class T>
 struct some_alloc
 {
     typedef T value_type;
-    
+
     some_alloc() {}
     some_alloc(const some_alloc&);
     void deallocate(void*, unsigned) {}
@@ -40,7 +43,7 @@ template <class T>
 struct some_alloc2
 {
     typedef T value_type;
-    
+
     some_alloc2() {}
     some_alloc2(const some_alloc2&);
     void deallocate(void*, unsigned) {}
@@ -51,7 +54,6 @@ struct some_alloc2
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::deque<MoveOnly> C;
         C c1, c2;
@@ -86,5 +88,4 @@ int main()
     }
 #endif
 
-#endif
 }
diff --git a/test/std/containers/sequences/deque/iterators.pass.cpp b/test/std/containers/sequences/deque/iterators.pass.cpp
index 8ec491fae4da..19d7996f824f 100644
--- a/test/std/containers/sequences/deque/iterators.pass.cpp
+++ b/test/std/containers/sequences/deque/iterators.pass.cpp
@@ -33,7 +33,7 @@ int main()
     j = c.cbegin();
     assert(i == j);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::deque<int, min_allocator<int>> C;
     C c;
@@ -68,7 +68,7 @@ int main()
         assert ( (cii >= ii1 ));
         assert (cii - ii1 == 0);
         assert (ii1 - cii == 0);
-        
+
 //         std::deque<int> c;
 //         assert ( ii1 != c.cbegin());
 //         assert ( cii != c.begin());
diff --git a/test/std/containers/sequences/deque/types.pass.cpp b/test/std/containers/sequences/deque/types.pass.cpp
index da9470d8a6c6..53b33d9e6be9 100644
--- a/test/std/containers/sequences/deque/types.pass.cpp
+++ b/test/std/containers/sequences/deque/types.pass.cpp
@@ -64,6 +64,12 @@ test()
     static_assert((std::is_same<
         typename C::const_reverse_iterator,
         std::reverse_iterator<typename C::const_iterator> >::value), "");
+    static_assert((std::is_signed<typename C::difference_type>::value), "");
+    static_assert((std::is_unsigned<typename C::size_type>::value), "");
+    static_assert((std::is_same<typename C::difference_type,
+        typename std::iterator_traits<typename C::iterator>::difference_type>::value), "");
+    static_assert((std::is_same<typename C::difference_type,
+        typename std::iterator_traits<typename C::const_iterator>::difference_type>::value), "");
 }
 
 int main()
@@ -73,7 +79,8 @@ int main()
     test<Copyable, test_allocator<Copyable> >();
     static_assert((std::is_same<std::deque<char>::allocator_type,
                                 std::allocator<char> >::value), "");
-#if __cplusplus >= 201103L
+
+#if TEST_STD_VER >= 11
     {
         typedef std::deque<short, min_allocator<short>> C;
         static_assert((std::is_same<C::value_type, short>::value), "");
@@ -85,6 +92,13 @@ int main()
 //  min_allocator doesn't have a size_type, so one gets synthesized
         static_assert((std::is_same<C::size_type, std::make_unsigned<C::difference_type>::type>::value), "");
         static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
+
+        static_assert((std::is_signed<typename C::difference_type>::value), "");
+        static_assert((std::is_unsigned<typename C::size_type>::value), "");
+        static_assert((std::is_same<typename C::difference_type,
+            typename std::iterator_traits<typename C::iterator>::difference_type>::value), "");
+        static_assert((std::is_same<typename C::difference_type,
+            typename std::iterator_traits<typename C::const_iterator>::difference_type>::value), "");
     }
 #endif
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.access/front.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.access/front.pass.cpp
index 2ec9b8713326..ae14eda50173 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.access/front.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.access/front.pass.cpp
@@ -38,7 +38,7 @@ int main()
         assert(c.front() == 0);
         assert(*c.begin() == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.pass.cpp
index 7aba906ec20d..352945c852d8 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.pass.cpp
@@ -28,7 +28,7 @@ int main()
         assert(c.get_allocator() == A(12));
         assert(c.empty());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef min_allocator<NotConstructible> A;
         typedef A::value_type T;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_copy.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_copy.pass.cpp
index 0b9263db9899..244054477d56 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_copy.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_copy.pass.cpp
@@ -117,7 +117,7 @@ int main()
         assert(c1 == c0);
         assert(c1.get_allocator() == A(10));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef min_allocator<int> A;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_init.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_init.pass.cpp
index e0382a10db49..d4dda02b8413 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_init.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_init.pass.cpp
@@ -42,7 +42,7 @@ int main()
             assert(*i == 10+n);
         assert(n == 4);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_move.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_move.pass.cpp
index 1532b53e7a83..935284831d07 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_move.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_move.pass.cpp
@@ -159,7 +159,7 @@ int main()
         assert(c1.get_allocator() == A(10));
         assert(c0.empty());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef MoveOnly T;
         typedef min_allocator<T> A;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_op_init.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_op_init.pass.cpp
index 551908fea166..3d35916ccacb 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_op_init.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_op_init.pass.cpp
@@ -42,7 +42,7 @@ int main()
             assert(*i == 10+n);
         assert(n == 4);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_range.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_range.pass.cpp
index 0b348e6920ca..ccefa2df7ce0 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_range.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_range.pass.cpp
@@ -47,7 +47,7 @@ int main()
             assert(*i == 10+n);
         assert(n == 4);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_size_value.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_size_value.pass.cpp
index ea53e1c37320..1a1610d37c2f 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_size_value.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_size_value.pass.cpp
@@ -41,7 +41,7 @@ int main()
             assert(*i == 10);
         assert(n == 4);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/copy.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/copy.pass.cpp
index 2fc53bc3a514..5240afa82b80 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/copy.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/copy.pass.cpp
@@ -50,7 +50,7 @@ int main()
         assert(c.get_allocator() == A(-2));
     }
 #endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef min_allocator<int> A;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/copy_alloc.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/copy_alloc.pass.cpp
index bcc24e1cc68e..e4b73bb54e9b 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/copy_alloc.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/copy_alloc.pass.cpp
@@ -48,7 +48,7 @@ int main()
         assert(c == c0);
         assert(c.get_allocator() == A(9));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef min_allocator<int> A;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/default.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/default.pass.cpp
index 38e95fad8396..04c4524cf980 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/default.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/default.pass.cpp
@@ -24,7 +24,7 @@ int main()
         C c;
         assert(c.empty());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/default_noexcept.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/default_noexcept.pass.cpp
index 5167a065a9ad..0ec1f80562a8 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/default_noexcept.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/default_noexcept.pass.cpp
@@ -14,9 +14,12 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <forward_list>
 #include <cassert>
 
+#include "test_macros.h"
 #include "MoveOnly.h"
 #include "test_allocator.h"
 
@@ -29,14 +32,13 @@ struct some_alloc
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::forward_list<MoveOnly> C;
-        static_assert(std::is_nothrow_default_constructible<C>::value, "");
+        LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
     }
     {
         typedef std::forward_list<MoveOnly, test_allocator<MoveOnly>> C;
-        static_assert(std::is_nothrow_default_constructible<C>::value, "");
+        LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
     }
     {
         typedef std::forward_list<MoveOnly, other_allocator<MoveOnly>> C;
@@ -46,5 +48,4 @@ int main()
         typedef std::forward_list<MoveOnly, some_alloc<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/dtor_noexcept.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/dtor_noexcept.pass.cpp
index da41bf4eb1fc..85d929b4e32e 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/dtor_noexcept.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/dtor_noexcept.pass.cpp
@@ -11,14 +11,14 @@
 
 // ~forward_list() // implied noexcept;
 
+// UNSUPPORTED: c++98, c++03
+
 #include <forward_list>
 #include <cassert>
 
 #include "MoveOnly.h"
 #include "test_allocator.h"
 
-#if __has_feature(cxx_noexcept)
-
 template <class T>
 struct some_alloc
 {
@@ -27,11 +27,8 @@ struct some_alloc
     ~some_alloc() noexcept(false);
 };
 
-#endif
-
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::forward_list<MoveOnly> C;
         static_assert(std::is_nothrow_destructible<C>::value, "");
@@ -48,5 +45,4 @@ int main()
         typedef std::forward_list<MoveOnly, some_alloc<MoveOnly>> C;
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/init.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/init.pass.cpp
index 5b31c4dad0a0..c783f60ff4c9 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/init.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/init.pass.cpp
@@ -28,7 +28,7 @@ int main()
             assert(*i == n);
         assert(n == 10);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/init_alloc.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/init_alloc.pass.cpp
index 750486b829f2..ba9984f969b5 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/init_alloc.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/init_alloc.pass.cpp
@@ -31,7 +31,7 @@ int main()
         assert(n == 10);
         assert(c.get_allocator() == A(14));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef min_allocator<T> A;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/move.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/move.pass.cpp
index 88ecb7540951..a3e204ec28da 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/move.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/move.pass.cpp
@@ -52,7 +52,7 @@ int main()
         assert(c0.empty());
         assert(c.get_allocator() == A(10));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef MoveOnly T;
         typedef min_allocator<T> A;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/move_alloc.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/move_alloc.pass.cpp
index 3f0e45af1f0b..6a1afe1334b0 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/move_alloc.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/move_alloc.pass.cpp
@@ -52,7 +52,7 @@ int main()
         assert(!c0.empty());
         assert(c.get_allocator() == A(9));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef MoveOnly T;
         typedef min_allocator<T> A;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/move_assign_noexcept.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/move_assign_noexcept.pass.cpp
index 28ce2c12b619..b9a6ef7ab8a8 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/move_assign_noexcept.pass.cpp
@@ -16,6 +16,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <forward_list>
 #include <cassert>
 
@@ -31,7 +33,6 @@ struct some_alloc
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::forward_list<MoveOnly> C;
         static_assert(std::is_nothrow_move_assignable<C>::value, "");
@@ -48,5 +49,4 @@ int main()
         typedef std::forward_list<MoveOnly, some_alloc<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/move_noexcept.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/move_noexcept.pass.cpp
index 7b001ea67b19..0359133afc9b 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/move_noexcept.pass.cpp
@@ -14,6 +14,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <forward_list>
 #include <cassert>
 
@@ -29,7 +31,6 @@ struct some_alloc
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::forward_list<MoveOnly> C;
         static_assert(std::is_nothrow_move_constructible<C>::value, "");
@@ -46,5 +47,4 @@ int main()
         typedef std::forward_list<MoveOnly, some_alloc<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/range.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/range.pass.cpp
index 763952439f00..3c0f2b8403ca 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/range.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/range.pass.cpp
@@ -32,7 +32,7 @@ int main()
             assert(*i == n);
         assert(n == std::end(t) - std::begin(t));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/range_alloc.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/range_alloc.pass.cpp
index d72c3581022d..96a29d24e89c 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/range_alloc.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/range_alloc.pass.cpp
@@ -36,7 +36,7 @@ int main()
         assert(n == std::end(t) - std::begin(t));
         assert(c.get_allocator() == A(13));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef min_allocator<T> A;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/size.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/size.pass.cpp
index e02dcb4bf691..736d59936aa3 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/size.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/size.pass.cpp
@@ -45,7 +45,7 @@ int main()
 #endif
         assert(n == N);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef DefaultOnly T;
         typedef std::forward_list<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/size_value.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/size_value.pass.cpp
index 05ab98bb205d..56ce632e0a48 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/size_value.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/size_value.pass.cpp
@@ -29,7 +29,7 @@ int main()
             assert(*i == v);
         assert(n == N);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/size_value_alloc.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/size_value_alloc.pass.cpp
index 1d631ab12ba1..86338a275a55 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/size_value_alloc.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/size_value_alloc.pass.cpp
@@ -32,7 +32,7 @@ int main()
         assert(n == N);
         assert(c.get_allocator() == A(12));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef min_allocator<int> A;
         typedef A::value_type T;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.iter/before_begin.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.iter/before_begin.pass.cpp
index 083cec2886da..c6104e73350b 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.iter/before_begin.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.iter/before_begin.pass.cpp
@@ -60,7 +60,7 @@ int main()
         C::const_iterator i = c.before_begin();
         assert(std::distance(i, c.end()) == 11);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.iter/iterators.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.iter/iterators.pass.cpp
index 6f3ac548db8b..925cca4d5e8d 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.iter/iterators.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.iter/iterators.pass.cpp
@@ -71,7 +71,7 @@ int main()
         C::iterator i;
         C::const_iterator j;
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
@@ -127,7 +127,7 @@ int main()
         std::forward_list<int>::const_iterator cii{};
         assert ( ii1 == ii2 );
         assert ( ii1 == ii4 );
- 
+
         assert (!(ii1 != ii2 ));
 
         assert ( (ii1 == cii ));
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/clear.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/clear.pass.cpp
index 2739b49d8eb2..0e625ac76a02 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/clear.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/clear.pass.cpp
@@ -38,7 +38,7 @@ int main()
         c.clear();
         assert(distance(c.begin(), c.end()) == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef NotConstructible T;
         typedef std::forward_list<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/emplace_after.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/emplace_after.pass.cpp
index e305c5b6ab52..dd8ea88c2c1a 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/emplace_after.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/emplace_after.pass.cpp
@@ -52,7 +52,7 @@ int main()
         assert(*next(c.begin(), 3) == Emplaceable(2, 3.5));
         assert(distance(c.begin(), c.end()) == 4);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef Emplaceable T;
         typedef std::forward_list<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/emplace_front.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/emplace_front.pass.cpp
index c02337e0562d..18ed69d33f0b 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/emplace_front.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/emplace_front.pass.cpp
@@ -32,7 +32,7 @@ int main()
         assert(*next(c.begin()) == Emplaceable());
         assert(distance(c.begin(), c.end()) == 2);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef Emplaceable T;
         typedef std::forward_list<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_many.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_many.pass.cpp
index bd9b15300efa..df859c69a117 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_many.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_many.pass.cpp
@@ -84,7 +84,7 @@ int main()
         assert(i == c.end());
         assert(distance(c.begin(), c.end()) == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_one.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_one.pass.cpp
index 4f51498bc651..bf6a88a65406 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_one.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_one.pass.cpp
@@ -55,7 +55,7 @@ int main()
         assert(i == c.end());
         assert(distance(c.begin(), c.end()) == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_const.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_const.pass.cpp
index ec650b695727..82dca739410f 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_const.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_const.pass.cpp
@@ -50,7 +50,7 @@ int main()
         assert(*next(c.begin(), 3) == 2);
         assert(distance(c.begin(), c.end()) == 4);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_init.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_init.pass.cpp
index 4d3018199809..15e1a08b08bf 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_init.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_init.pass.cpp
@@ -44,7 +44,7 @@ int main()
         assert(*next(c.begin(), 3) == 1);
         assert(*next(c.begin(), 4) == 2);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_range.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_range.pass.cpp
index 103475f1edab..a41f8dbbfb2b 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_range.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_range.pass.cpp
@@ -48,7 +48,7 @@ int main()
         assert(*next(c.begin(), 3) == 1);
         assert(*next(c.begin(), 4) == 2);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_rv.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_rv.pass.cpp
index f7f376caa090..2e21cc79d269 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_rv.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_rv.pass.cpp
@@ -52,7 +52,7 @@ int main()
         assert(*next(c.begin(), 3) == 2);
         assert(distance(c.begin(), c.end()) == 4);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef MoveOnly T;
         typedef std::forward_list<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_size_value.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_size_value.pass.cpp
index b2da2ecd3bbd..f4b7e344112a 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_size_value.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_size_value.pass.cpp
@@ -43,7 +43,7 @@ int main()
         assert(*next(c.begin(), 3) == 3);
         assert(*next(c.begin(), 4) == 3);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/pop_front.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/pop_front.pass.cpp
index 7f14e54a2e6f..d831ceb28918 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/pop_front.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/pop_front.pass.cpp
@@ -46,7 +46,7 @@ int main()
         assert(distance(c.begin(), c.end()) == 0);
     }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_const.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_const.pass.cpp
index 85958afc1ce3..4b55a0b1d808 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_const.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_const.pass.cpp
@@ -30,7 +30,7 @@ int main()
         assert(*next(c.begin()) == 1);
         assert(distance(c.begin(), c.end()) == 2);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_rv.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_rv.pass.cpp
index d7c9d758aa03..dfcd2cf90ebc 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_rv.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_rv.pass.cpp
@@ -32,7 +32,7 @@ int main()
         assert(*next(c.begin()) == 1);
         assert(distance(c.begin(), c.end()) == 2);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef MoveOnly T;
         typedef std::forward_list<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size.pass.cpp
index ef7ef82626dc..6337cd779722 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size.pass.cpp
@@ -64,7 +64,7 @@ int main()
         assert(*next(c.begin(), 4) == 0);
         assert(*next(c.begin(), 5) == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef DefaultOnly T;
         typedef std::forward_list<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size_value.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size_value.pass.cpp
index d4bd6b4e0111..356e0d657c35 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size_value.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size_value.pass.cpp
@@ -14,9 +14,14 @@
 #include <forward_list>
 #include <cassert>
 
+#include "test_macros.h"
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 
+#if TEST_STD_VER >= 11
+#include "container_test_types.h"
+#endif
+
 int main()
 {
     {
@@ -49,7 +54,7 @@ int main()
         assert(*next(c.begin(), 4) == 10);
         assert(*next(c.begin(), 5) == 10);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
@@ -80,5 +85,19 @@ int main()
         assert(*next(c.begin(), 4) == 10);
         assert(*next(c.begin(), 5) == 10);
     }
+    {
+        // Test that the allocator's construct method is being used to
+        // construct the new elements and that it's called exactly N times.
+        typedef int T;
+        typedef std::forward_list<int, ContainerTestAllocator<int, int>> Container;
+        ConstructController* cc = getConstructController();
+        cc->reset();
+        {
+            Container c;
+            cc->expect<int const&>(6);
+            c.resize(6, 42);
+            assert(!cc->unchecked());
+        }
+    }
 #endif
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/merge.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/merge.pass.cpp
index 3b6f853c84cd..a67dd1a4b120 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/merge.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/merge.pass.cpp
@@ -31,7 +31,7 @@ int main()
         C c3(std::begin(t3), std::end(t3));
         assert(c1 == c3);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/merge_pred.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/merge_pred.pass.cpp
index 7e873bdddd09..6b4e323bd02d 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/merge_pred.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/merge_pred.pass.cpp
@@ -32,7 +32,7 @@ int main()
         C c3(std::begin(t3), std::end(t3));
         assert(c1 == c3);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/remove.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/remove.pass.cpp
index 18d4cae8cc61..b7607e190bbf 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/remove.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/remove.pass.cpp
@@ -103,7 +103,7 @@ int main()
         }
     assert ( it == c.end ());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/remove_if.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/remove_if.pass.cpp
index ed408fbd685c..ef6f6a0f1887 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/remove_if.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/remove_if.pass.cpp
@@ -88,7 +88,7 @@ int main()
         assert(c1 == c2);
         assert(cp.count() == std::distance(std::begin(t1), std::end(t1)));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef unary_counting_predicate<bool(*)(T), T> Predicate;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/reverse.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/reverse.pass.cpp
index 9bf0d03a8855..2876f65d0630 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/reverse.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/reverse.pass.cpp
@@ -35,7 +35,7 @@ int main()
 {
     for (int i = 0; i < 10; ++i)
         test<std::forward_list<int> >(i);
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     for (int i = 0; i < 10; ++i)
         test<std::forward_list<int, min_allocator<int>> >(i);
 #endif
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/sort.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/sort.pass.cpp
index 06e40c595ecb..65512e317cea 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/sort.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/sort.pass.cpp
@@ -40,7 +40,7 @@ int main()
 {
     for (int i = 0; i < 40; ++i)
         test<std::forward_list<int> >(i);
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     for (int i = 0; i < 40; ++i)
         test<std::forward_list<int, min_allocator<int>> >(i);
 #endif
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/sort_pred.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/sort_pred.pass.cpp
index 8b6ca39b2aab..6e5cce39e67d 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/sort_pred.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/sort_pred.pass.cpp
@@ -41,7 +41,7 @@ int main()
 {
     for (int i = 0; i < 40; ++i)
         test<std::forward_list<int> >(i);
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     for (int i = 0; i < 40; ++i)
         test<std::forward_list<int, min_allocator<int>> >(i);
 #endif
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_flist.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_flist.pass.cpp
index 51da651970cd..c8d4e2d34f1e 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_flist.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_flist.pass.cpp
@@ -55,7 +55,7 @@ int main()
         }
     }
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     // splicing different containers
     typedef std::forward_list<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_range.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_range.pass.cpp
index 90a159959632..006869d6db69 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_range.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_range.pass.cpp
@@ -121,7 +121,7 @@ int main()
         }
     }
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     // splicing different containers
     typedef std::forward_list<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/unique.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/unique.pass.cpp
index 25db6e64b8a9..e79abb6b6519 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/unique.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/unique.pass.cpp
@@ -67,7 +67,7 @@ int main()
         c1.unique();
         assert(c1 == c2);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/unique_pred.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/unique_pred.pass.cpp
index b7dce20b7092..11228afe83e6 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/unique_pred.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/unique_pred.pass.cpp
@@ -72,7 +72,7 @@ int main()
         c1.unique(g);
         assert(c1 == c2);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.spec/member_swap.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.spec/member_swap.pass.cpp
index 2b2be7b6c222..e7a8d048f6f6 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.spec/member_swap.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.spec/member_swap.pass.cpp
@@ -176,7 +176,7 @@ int main()
         assert(distance(c2.begin(), c2.end()) == 0);
         assert(c2.get_allocator() == A(1));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef min_allocator<T> A;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.spec/non_member_swap.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.spec/non_member_swap.pass.cpp
index d6ba5a47cbe6..983d8140571b 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.spec/non_member_swap.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.spec/non_member_swap.pass.cpp
@@ -177,7 +177,7 @@ int main()
         assert(distance(c2.begin(), c2.end()) == 0);
         assert(c2.get_allocator() == A(1));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef min_allocator<T> A;
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.spec/swap_noexcept.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.spec/swap_noexcept.pass.cpp
index cbe8142eeb4b..5f8cf95aa737 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.spec/swap_noexcept.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.spec/swap_noexcept.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <forward_list>
 
 // void swap(forward_list& c)
@@ -21,6 +23,7 @@
 #include <forward_list>
 #include <cassert>
 
+#include "test_macros.h"
 #include "MoveOnly.h"
 #include "test_allocator.h"
 
@@ -28,7 +31,7 @@ template <class T>
 struct some_alloc
 {
     typedef T value_type;
-    
+
     some_alloc() {}
     some_alloc(const some_alloc&);
     void deallocate(void*, unsigned) {}
@@ -40,7 +43,7 @@ template <class T>
 struct some_alloc2
 {
     typedef T value_type;
-    
+
     some_alloc2() {}
     some_alloc2(const some_alloc2&);
     void deallocate(void*, unsigned) {}
@@ -51,7 +54,6 @@ struct some_alloc2
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::forward_list<MoveOnly> C;
         C c1, c2;
@@ -85,6 +87,4 @@ int main()
         static_assert( noexcept(swap(c1, c2)), "");
     }
 #endif
-
-#endif
 }
diff --git a/test/std/containers/sequences/forwardlist/incomplete.pass.cpp b/test/std/containers/sequences/forwardlist/incomplete.pass.cpp
new file mode 100644
index 000000000000..df273449eac1
--- /dev/null
+++ b/test/std/containers/sequences/forwardlist/incomplete.pass.cpp
@@ -0,0 +1,53 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <forward_list>
+
+// forward_list()
+// forward_list::iterator()
+// forward_list::const_iterator()
+
+#include <forward_list>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+struct A {
+  std::forward_list<A> d;
+  std::forward_list<A>::iterator it;
+  std::forward_list<A>::const_iterator it2;
+};
+
+#if TEST_STD_VER >= 11
+struct B {
+  typedef std::forward_list<B, min_allocator<B>> FList;
+  FList d;
+  FList::iterator it;
+  FList::const_iterator it2;
+};
+#endif
+
+int main()
+{
+  {
+    A a;
+    assert(a.d.empty());
+    a.it = a.d.begin();
+    a.it2 = a.d.cbefore_begin();
+  }
+#if TEST_STD_VER >= 11
+  {
+    B b;
+    assert(b.d.empty());
+    b.it = b.d.begin();
+    b.it2 = b.d.cbefore_begin();
+  }
+#endif
+}
diff --git a/test/std/containers/sequences/forwardlist/max_size.pass.cpp b/test/std/containers/sequences/forwardlist/max_size.pass.cpp
index be7ebaf44b03..a7f39bf90fb8 100644
--- a/test/std/containers/sequences/forwardlist/max_size.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/max_size.pass.cpp
@@ -24,7 +24,7 @@ int main()
         C c;
         assert(c.max_size() > 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/forwardlist/types.pass.cpp b/test/std/containers/sequences/forwardlist/types.pass.cpp
index a1f8862debbe..5ed7e34b9202 100644
--- a/test/std/containers/sequences/forwardlist/types.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/types.pass.cpp
@@ -44,8 +44,15 @@ int main()
     static_assert((std::is_same<C::const_pointer, const char*>::value), "");
     static_assert((std::is_same<C::size_type, std::size_t>::value), "");
     static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
+
+    static_assert((std::is_signed<typename C::difference_type>::value), "");
+    static_assert((std::is_unsigned<typename C::size_type>::value), "");
+    static_assert((std::is_same<typename C::difference_type,
+        typename std::iterator_traits<typename C::iterator>::difference_type>::value), "");
+    static_assert((std::is_same<typename C::difference_type,
+        typename std::iterator_traits<typename C::const_iterator>::difference_type>::value), "");
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::forward_list<char, min_allocator<char>> C;
     static_assert((std::is_same<C::value_type, char>::value), "");
@@ -57,6 +64,13 @@ int main()
 //  min_allocator doesn't have a size_type, so one gets synthesized
     static_assert((std::is_same<C::size_type, std::make_unsigned<C::difference_type>::type>::value), "");
     static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
+
+    static_assert((std::is_signed<typename C::difference_type>::value), "");
+    static_assert((std::is_unsigned<typename C::size_type>::value), "");
+    static_assert((std::is_same<typename C::difference_type,
+        typename std::iterator_traits<typename C::iterator>::difference_type>::value), "");
+    static_assert((std::is_same<typename C::difference_type,
+        typename std::iterator_traits<typename C::const_iterator>::difference_type>::value), "");
     }
 #endif
 }
diff --git a/test/std/containers/sequences/list/iterators.pass.cpp b/test/std/containers/sequences/list/iterators.pass.cpp
index a33ee3ecd2db..fe0ac0799687 100644
--- a/test/std/containers/sequences/list/iterators.pass.cpp
+++ b/test/std/containers/sequences/list/iterators.pass.cpp
@@ -77,7 +77,7 @@ int main()
         C::iterator i;
         C::const_iterator j;
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::list<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/list/list.capacity/resize_size.pass.cpp b/test/std/containers/sequences/list/list.capacity/resize_size.pass.cpp
index 14629b173a6c..df934699d5ad 100644
--- a/test/std/containers/sequences/list/list.capacity/resize_size.pass.cpp
+++ b/test/std/containers/sequences/list/list.capacity/resize_size.pass.cpp
@@ -47,7 +47,7 @@ int main()
         assert(std::distance(l.begin(), l.end()) == 20);
     }
 #endif  // __LIBCPP_MOVE
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::list<int, min_allocator<int>> l(5, 2);
         l.resize(2);
diff --git a/test/std/containers/sequences/list/list.capacity/resize_size_value.pass.cpp b/test/std/containers/sequences/list/list.capacity/resize_size_value.pass.cpp
index 2738ffbbefdd..4609ef986835 100644
--- a/test/std/containers/sequences/list/list.capacity/resize_size_value.pass.cpp
+++ b/test/std/containers/sequences/list/list.capacity/resize_size_value.pass.cpp
@@ -33,7 +33,7 @@ int main()
         assert(l.front() == 2);
         assert(l.back() == 3.5);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::list<double, min_allocator<double>> l(5, 2);
         l.resize(2, 3.5);
diff --git a/test/std/containers/sequences/list/list.cons/assign_copy.pass.cpp b/test/std/containers/sequences/list/list.cons/assign_copy.pass.cpp
index b851eb9dc5a0..7c8cee2a5581 100644
--- a/test/std/containers/sequences/list/list.cons/assign_copy.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/assign_copy.pass.cpp
@@ -32,7 +32,7 @@ int main()
         assert(l2 == l);
         assert(l2.get_allocator() == other_allocator<int>(5));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::list<int, min_allocator<int> > l(3, 2, min_allocator<int>());
         std::list<int, min_allocator<int> > l2(l, min_allocator<int>());
diff --git a/test/std/containers/sequences/list/list.cons/assign_initializer_list.pass.cpp b/test/std/containers/sequences/list/list.cons/assign_initializer_list.pass.cpp
index 24bd140c4e4f..9b2c6d68cbe5 100644
--- a/test/std/containers/sequences/list/list.cons/assign_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/assign_initializer_list.pass.cpp
@@ -29,7 +29,7 @@ int main()
     assert(*i++ == 5);
     assert(*i++ == 6);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     std::list<int, min_allocator<int>> d;
     d.assign({3, 4, 5, 6});
diff --git a/test/std/containers/sequences/list/list.cons/assign_move.pass.cpp b/test/std/containers/sequences/list/list.cons/assign_move.pass.cpp
index 0fd586f84af7..2f863c6169fc 100644
--- a/test/std/containers/sequences/list/list.cons/assign_move.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/assign_move.pass.cpp
@@ -62,7 +62,7 @@ int main()
         assert(l.empty());
         assert(l2.get_allocator() == lo.get_allocator());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::list<MoveOnly, min_allocator<MoveOnly> > l(min_allocator<MoveOnly>{});
         std::list<MoveOnly, min_allocator<MoveOnly> > lo(min_allocator<MoveOnly>{});
diff --git a/test/std/containers/sequences/list/list.cons/copy.pass.cpp b/test/std/containers/sequences/list/list.cons/copy.pass.cpp
index 530690a925d4..a6abd1f3c30b 100644
--- a/test/std/containers/sequences/list/list.cons/copy.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/copy.pass.cpp
@@ -38,7 +38,7 @@ int main()
         assert(l2.get_allocator() == other_allocator<int>(-2));
     }
 #endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::list<int, min_allocator<int>> l(3, 2);
         std::list<int, min_allocator<int>> l2 = l;
diff --git a/test/std/containers/sequences/list/list.cons/copy_alloc.pass.cpp b/test/std/containers/sequences/list/list.cons/copy_alloc.pass.cpp
index 99fe9f115f94..a164298f4fae 100644
--- a/test/std/containers/sequences/list/list.cons/copy_alloc.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/copy_alloc.pass.cpp
@@ -31,7 +31,7 @@ int main()
         assert(l2 == l);
         assert(l2.get_allocator() == other_allocator<int>(3));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::list<int, min_allocator<int> > l(3, 2, min_allocator<int>());
         std::list<int, min_allocator<int> > l2(l, min_allocator<int>());
diff --git a/test/std/containers/sequences/list/list.cons/default.pass.cpp b/test/std/containers/sequences/list/list.cons/default.pass.cpp
index c05bd74ca79e..3c1c2ef166d4 100644
--- a/test/std/containers/sequences/list/list.cons/default.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/default.pass.cpp
@@ -33,7 +33,7 @@ int main()
         assert(l.size() == 0);
         assert(std::distance(l.begin(), l.end()) == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::list<int, min_allocator<int>> l;
         assert(l.size() == 0);
diff --git a/test/std/containers/sequences/list/list.cons/default_noexcept.pass.cpp b/test/std/containers/sequences/list/list.cons/default_noexcept.pass.cpp
index 2455fb39a79a..6f76d8c56882 100644
--- a/test/std/containers/sequences/list/list.cons/default_noexcept.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/default_noexcept.pass.cpp
@@ -14,9 +14,12 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <list>
 #include <cassert>
 
+#include "test_macros.h"
 #include "MoveOnly.h"
 #include "test_allocator.h"
 
@@ -29,14 +32,13 @@ struct some_alloc
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::list<MoveOnly> C;
-        static_assert(std::is_nothrow_default_constructible<C>::value, "");
+        LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
     }
     {
         typedef std::list<MoveOnly, test_allocator<MoveOnly>> C;
-        static_assert(std::is_nothrow_default_constructible<C>::value, "");
+        LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
     }
     {
         typedef std::list<MoveOnly, other_allocator<MoveOnly>> C;
@@ -46,5 +48,4 @@ int main()
         typedef std::list<MoveOnly, some_alloc<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/sequences/list/list.cons/default_stack_alloc.pass.cpp b/test/std/containers/sequences/list/list.cons/default_stack_alloc.pass.cpp
index 9d9946b68966..4b88580e12ca 100644
--- a/test/std/containers/sequences/list/list.cons/default_stack_alloc.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/default_stack_alloc.pass.cpp
@@ -33,7 +33,7 @@ int main()
         assert(l.size() == 0);
         assert(std::distance(l.begin(), l.end()) == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::list<int, min_allocator<int>> l;
         assert(l.size() == 0);
diff --git a/test/std/containers/sequences/list/list.cons/dtor_noexcept.pass.cpp b/test/std/containers/sequences/list/list.cons/dtor_noexcept.pass.cpp
index ca7ade6d19cb..3d11f13358b5 100644
--- a/test/std/containers/sequences/list/list.cons/dtor_noexcept.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/dtor_noexcept.pass.cpp
@@ -11,14 +11,14 @@
 
 // ~list() // implied noexcept;
 
+// UNSUPPORTED: c++98, c++03
+
 #include <list>
 #include <cassert>
 
 #include "MoveOnly.h"
 #include "test_allocator.h"
 
-#if __has_feature(cxx_noexcept)
-
 template <class T>
 struct some_alloc
 {
@@ -27,11 +27,8 @@ struct some_alloc
     ~some_alloc() noexcept(false);
 };
 
-#endif
-
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::list<MoveOnly> C;
         static_assert(std::is_nothrow_destructible<C>::value, "");
@@ -48,5 +45,4 @@ int main()
         typedef std::list<MoveOnly, some_alloc<MoveOnly>> C;
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/sequences/list/list.cons/initializer_list.pass.cpp b/test/std/containers/sequences/list/list.cons/initializer_list.pass.cpp
index 3307017989eb..40413203bdfc 100644
--- a/test/std/containers/sequences/list/list.cons/initializer_list.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/initializer_list.pass.cpp
@@ -28,7 +28,7 @@ int main()
     assert(*i++ == 5);
     assert(*i++ == 6);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     std::list<int, min_allocator<int>> d = {3, 4, 5, 6};
     assert(d.size() == 4);
diff --git a/test/std/containers/sequences/list/list.cons/initializer_list_alloc.pass.cpp b/test/std/containers/sequences/list/list.cons/initializer_list_alloc.pass.cpp
index 4a85e378c1ce..72add79f6670 100644
--- a/test/std/containers/sequences/list/list.cons/initializer_list_alloc.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/initializer_list_alloc.pass.cpp
@@ -30,7 +30,7 @@ int main()
     assert(*i++ == 5);
     assert(*i++ == 6);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     std::list<int, min_allocator<int>> d({3, 4, 5, 6}, min_allocator<int>());
     assert(d.get_allocator() == min_allocator<int>());
diff --git a/test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp b/test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp
index 09eae8ab43c1..0dd71d70f85b 100644
--- a/test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp
@@ -51,7 +51,7 @@ int main()
         for (std::list<int>::const_iterator i = l.begin(), e = l.end(); i != e; ++i, ++j)
             assert(*i == j);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         int a[] = {0, 1, 2, 3};
         std::list<int, min_allocator<int>> l(input_iterator<const int*>(a),
diff --git a/test/std/containers/sequences/list/list.cons/move.pass.cpp b/test/std/containers/sequences/list/list.cons/move.pass.cpp
index 54209a55f7e2..1049b1b03982 100644
--- a/test/std/containers/sequences/list/list.cons/move.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/move.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <list>
 
 // list(list&& c);
@@ -19,7 +21,6 @@
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
         std::list<MoveOnly, test_allocator<MoveOnly> > l(test_allocator<MoveOnly>(5));
         std::list<MoveOnly, test_allocator<MoveOnly> > lo(test_allocator<MoveOnly>(5));
@@ -46,7 +47,6 @@ int main()
         assert(l.empty());
         assert(l2.get_allocator() == lo.get_allocator());
     }
-#if __cplusplus >= 201103L
     {
         std::list<MoveOnly, min_allocator<MoveOnly> > l(min_allocator<MoveOnly>{});
         std::list<MoveOnly, min_allocator<MoveOnly> > lo(min_allocator<MoveOnly>{});
@@ -60,15 +60,4 @@ int main()
         assert(l.empty());
         assert(l2.get_allocator() == lo.get_allocator());
     }
-#endif
-#if _LIBCPP_DEBUG >= 1
-    {
-        std::list<int> l1 = {1, 2, 3};
-        std::list<int>::iterator i = l1.begin();
-        std::list<int> l2 = std::move(l1);
-        assert(*l2.erase(i) == 2);
-        assert(l2.size() == 2);
-    }
-#endif
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/containers/sequences/list/list.cons/move_alloc.pass.cpp b/test/std/containers/sequences/list/list.cons/move_alloc.pass.cpp
index 8f82702b296f..9f8a536b33c5 100644
--- a/test/std/containers/sequences/list/list.cons/move_alloc.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/move_alloc.pass.cpp
@@ -59,7 +59,7 @@ int main()
         assert(!l.empty());
         assert(l2.get_allocator() == other_allocator<MoveOnly>(4));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::list<MoveOnly, min_allocator<MoveOnly> > l(min_allocator<MoveOnly>{});
         std::list<MoveOnly, min_allocator<MoveOnly> > lo(min_allocator<MoveOnly>{});
diff --git a/test/std/containers/sequences/list/list.cons/move_assign_noexcept.pass.cpp b/test/std/containers/sequences/list/list.cons/move_assign_noexcept.pass.cpp
index 280d93d486e6..d4f8fde2c8ff 100644
--- a/test/std/containers/sequences/list/list.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/move_assign_noexcept.pass.cpp
@@ -16,6 +16,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <list>
 #include <cassert>
 
@@ -31,7 +33,6 @@ struct some_alloc
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::list<MoveOnly> C;
         static_assert(std::is_nothrow_move_assignable<C>::value, "");
@@ -48,5 +49,4 @@ int main()
         typedef std::list<MoveOnly, some_alloc<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/sequences/list/list.cons/move_noexcept.pass.cpp b/test/std/containers/sequences/list/list.cons/move_noexcept.pass.cpp
index e436a29f5d47..da2b6a36cef5 100644
--- a/test/std/containers/sequences/list/list.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/move_noexcept.pass.cpp
@@ -14,6 +14,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <list>
 #include <cassert>
 
@@ -29,7 +31,6 @@ struct some_alloc
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::list<MoveOnly> C;
         static_assert(std::is_nothrow_move_constructible<C>::value, "");
@@ -46,5 +47,4 @@ int main()
         typedef std::list<MoveOnly, some_alloc<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/sequences/list/list.cons/op_equal_initializer_list.pass.cpp b/test/std/containers/sequences/list/list.cons/op_equal_initializer_list.pass.cpp
index 7b7b8a327b88..1097bdab2198 100644
--- a/test/std/containers/sequences/list/list.cons/op_equal_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/op_equal_initializer_list.pass.cpp
@@ -28,7 +28,7 @@ int main()
     assert(*i++ == 5);
     assert(*i++ == 6);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     std::list<int, min_allocator<int>> d;
     d = {3, 4, 5, 6};
diff --git a/test/std/containers/sequences/list/list.cons/size_type.pass.cpp b/test/std/containers/sequences/list/list.cons/size_type.pass.cpp
index 75b93a3dfb6b..07b4f14dc3a2 100644
--- a/test/std/containers/sequences/list/list.cons/size_type.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/size_type.pass.cpp
@@ -80,7 +80,7 @@ int main()
         assert(std::distance(l.begin(), l.end()) == 3);
     }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::list<int, min_allocator<int>> l(3);
         assert(l.size() == 3);
diff --git a/test/std/containers/sequences/list/list.cons/size_value_alloc.pass.cpp b/test/std/containers/sequences/list/list.cons/size_value_alloc.pass.cpp
index 12da86da0a41..ac7b18ea4990 100644
--- a/test/std/containers/sequences/list/list.cons/size_value_alloc.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/size_value_alloc.pass.cpp
@@ -52,7 +52,7 @@ int main()
         ++i;
         assert(*i == 2);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::list<int, min_allocator<int>> l(3, 2);
         assert(l.size() == 3);
diff --git a/test/std/containers/sequences/list/list.modifiers/clear.pass.cpp b/test/std/containers/sequences/list/list.modifiers/clear.pass.cpp
index 38696b6eb503..5d8c41fa1976 100644
--- a/test/std/containers/sequences/list/list.modifiers/clear.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/clear.pass.cpp
@@ -24,7 +24,7 @@ int main()
     c.clear();
     assert(c.empty());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     int a[] = {1, 2, 3};
     std::list<int, min_allocator<int>> c(a, a+3);
diff --git a/test/std/containers/sequences/list/list.modifiers/emplace.pass.cpp b/test/std/containers/sequences/list/list.modifiers/emplace.pass.cpp
index 6476d1d6c6ae..e8d46941252e 100644
--- a/test/std/containers/sequences/list/list.modifiers/emplace.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/emplace.pass.cpp
@@ -7,17 +7,17 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <list>
 
 // template <class... Args> void emplace(const_iterator p, Args&&... args);
 
-#if _LIBCPP_DEBUG >= 1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
-#endif
 
 #include <list>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 class A
@@ -37,7 +37,6 @@ public:
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
     std::list<A> c;
     c.emplace(c.cbegin(), 2, 3.5);
@@ -51,17 +50,6 @@ int main()
     assert(c.back().geti() == 3);
     assert(c.back().getd() == 4.5);
     }
-#if _LIBCPP_DEBUG >= 1
-    {
-        std::list<A> c1;
-        std::list<A> c2;
-        std::list<A>::iterator i = c1.emplace(c2.cbegin(), 2, 3.5);
-        assert(false);
-    }
-#endif
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#if __cplusplus >= 201103L
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
     std::list<A, min_allocator<A>> c;
     c.emplace(c.cbegin(), 2, 3.5);
@@ -75,14 +63,5 @@ int main()
     assert(c.back().geti() == 3);
     assert(c.back().getd() == 4.5);
     }
-#if _LIBCPP_DEBUG >= 1
-    {
-        std::list<A, min_allocator<A>> c1;
-        std::list<A, min_allocator<A>> c2;
-        std::list<A, min_allocator<A>>::iterator i = c1.emplace(c2.cbegin(), 2, 3.5);
-        assert(false);
-    }
-#endif
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#endif
+
 }
diff --git a/test/std/containers/sequences/list/list.modifiers/emplace_back.pass.cpp b/test/std/containers/sequences/list/list.modifiers/emplace_back.pass.cpp
index 5983efc59ad1..2ff01f1676f2 100644
--- a/test/std/containers/sequences/list/list.modifiers/emplace_back.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/emplace_back.pass.cpp
@@ -47,7 +47,7 @@ int main()
     assert(c.back().geti() == 3);
     assert(c.back().getd() == 4.5);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     std::list<A, min_allocator<A>> c;
     c.emplace_back(2, 3.5);
diff --git a/test/std/containers/sequences/list/list.modifiers/emplace_front.pass.cpp b/test/std/containers/sequences/list/list.modifiers/emplace_front.pass.cpp
index e2e68e331381..8a3df46a31e2 100644
--- a/test/std/containers/sequences/list/list.modifiers/emplace_front.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/emplace_front.pass.cpp
@@ -47,7 +47,7 @@ int main()
     assert(c.back().geti() == 2);
     assert(c.back().getd() == 3.5);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     std::list<A, min_allocator<A>> c;
     c.emplace_front(2, 3.5);
diff --git a/test/std/containers/sequences/list/list.modifiers/erase_iter.pass.cpp b/test/std/containers/sequences/list/list.modifiers/erase_iter.pass.cpp
index c1cc90043670..0924fdb84879 100644
--- a/test/std/containers/sequences/list/list.modifiers/erase_iter.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/erase_iter.pass.cpp
@@ -39,7 +39,7 @@ int main()
     assert(l1.size() == 0);
     assert(distance(l1.begin(), l1.end()) == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     int a1[] = {1, 2, 3};
     std::list<int, min_allocator<int>> l1(a1, a1+3);
diff --git a/test/std/containers/sequences/list/list.modifiers/erase_iter_iter.pass.cpp b/test/std/containers/sequences/list/list.modifiers/erase_iter_iter.pass.cpp
index bd3f66b4116a..06b4f0cc654f 100644
--- a/test/std/containers/sequences/list/list.modifiers/erase_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/erase_iter_iter.pass.cpp
@@ -49,7 +49,7 @@ int main()
         assert(distance(l1.cbegin(), l1.cend()) == 0);
         assert(i == l1.begin());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::list<int, min_allocator<int>> l1(a1, a1+3);
         std::list<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), l1.cbegin());
diff --git a/test/std/containers/sequences/list/list.modifiers/insert_iter_initializer_list.pass.cpp b/test/std/containers/sequences/list/list.modifiers/insert_iter_initializer_list.pass.cpp
index a82a2696e82a..91845e564b02 100644
--- a/test/std/containers/sequences/list/list.modifiers/insert_iter_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/insert_iter_initializer_list.pass.cpp
@@ -40,7 +40,7 @@ int main()
     assert(*i++ == 1);
     assert(*i++ == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     std::list<int, min_allocator<int>> d(10, 1);
     std::list<int, min_allocator<int>>::iterator i = d.insert(next(d.cbegin(), 2), {3, 4, 5, 6});
diff --git a/test/std/containers/sequences/list/list.modifiers/insert_iter_iter_iter.pass.cpp b/test/std/containers/sequences/list/list.modifiers/insert_iter_iter_iter.pass.cpp
index 736b9baae746..18460a65743c 100644
--- a/test/std/containers/sequences/list/list.modifiers/insert_iter_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/insert_iter_iter_iter.pass.cpp
@@ -7,117 +7,25 @@
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <list>
 
 // template <InputIterator Iter>
 //   iterator insert(const_iterator position, Iter first, Iter last);
 
-// UNSUPPORTED: sanitizer-new-delete
-
-#if _LIBCPP_DEBUG >= 1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
-#endif
-
 #include <list>
 #include <cstdlib>
 #include <cassert>
+
+#include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
+#include "count_new.hpp"
 
-int throw_next = 0xFFFF;
-int count = 0;
-
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    if (throw_next == 0)
-        throw std::bad_alloc();
-    --throw_next;
-    ++count;
-    return std::malloc(s);
-}
-
-void  operator delete(void* p) throw()
-{
-    --count;
-    std::free(p);
-}
-
-int main()
-{
-    {
-    int a1[] = {1, 2, 3};
-    std::list<int> l1;
-    std::list<int>::iterator i = l1.insert(l1.begin(), a1, a1+3);
-    assert(i == l1.begin());
-    assert(l1.size() == 3);
-    assert(distance(l1.begin(), l1.end()) == 3);
-    i = l1.begin();
-    assert(*i == 1);
-    ++i;
-    assert(*i == 2);
-    ++i;
-    assert(*i == 3);
-    int a2[] = {4, 5, 6};
-    i = l1.insert(i, a2, a2+3);
-    assert(*i == 4);
-    assert(l1.size() == 6);
-    assert(distance(l1.begin(), l1.end()) == 6);
-    i = l1.begin();
-    assert(*i == 1);
-    ++i;
-    assert(*i == 2);
-    ++i;
-    assert(*i == 4);
-    ++i;
-    assert(*i == 5);
-    ++i;
-    assert(*i == 6);
-    ++i;
-    assert(*i == 3);
-    throw_next = 2;
-    int save_count = count;
-    try
-    {
-        i = l1.insert(i, a2, a2+3);
-        assert(false);
-    }
-    catch (...)
-    {
-    }
-    assert(save_count == count);
-    assert(l1.size() == 6);
-    assert(distance(l1.begin(), l1.end()) == 6);
-    i = l1.begin();
-    assert(*i == 1);
-    ++i;
-    assert(*i == 2);
-    ++i;
-    assert(*i == 4);
-    ++i;
-    assert(*i == 5);
-    ++i;
-    assert(*i == 6);
-    ++i;
-    assert(*i == 3);
-    }
-    throw_next = 0xFFFF;
-#if _LIBCPP_DEBUG >= 1
-    {
-        std::list<int> v(100);
-        std::list<int> v2(100);
-        int a[] = {1, 2, 3, 4, 5};
-        const int N = sizeof(a)/sizeof(a[0]);
-        std::list<int>::iterator i = v.insert(next(v2.cbegin(), 10), input_iterator<const int*>(a),
-                                       input_iterator<const int*>(a+N));
-        assert(false);
-    }
-#endif
-#if __cplusplus >= 201103L
-    {
+template <class List>
+void test() {
     int a1[] = {1, 2, 3};
-    std::list<int, min_allocator<int>> l1;
-    std::list<int, min_allocator<int>>::iterator i = l1.insert(l1.begin(), a1, a1+3);
+    List l1;
+    typename List::iterator i = l1.insert(l1.begin(), a1, a1+3);
     assert(i == l1.begin());
     assert(l1.size() == 3);
     assert(distance(l1.begin(), l1.end()) == 3);
@@ -144,8 +52,10 @@ int main()
     assert(*i == 6);
     ++i;
     assert(*i == 3);
-    throw_next = 2;
-    int save_count = count;
+
+#if !defined(TEST_HAS_NO_EXCEPTIONS) && !defined(DISABLE_NEW_COUNT)
+    globalMemCounter.throw_after = 2;
+    int save_count = globalMemCounter.outstanding_new;
     try
     {
         i = l1.insert(i, a2, a2+3);
@@ -154,7 +64,7 @@ int main()
     catch (...)
     {
     }
-    assert(save_count == count);
+    assert(globalMemCounter.checkOutstandingNewEq(save_count));
     assert(l1.size() == 6);
     assert(distance(l1.begin(), l1.end()) == 6);
     i = l1.begin();
@@ -169,18 +79,13 @@ int main()
     assert(*i == 6);
     ++i;
     assert(*i == 3);
-    }
-#if _LIBCPP_DEBUG >= 1
-    {
-        throw_next = 0xFFFF;
-        std::list<int, min_allocator<int>> v(100);
-        std::list<int, min_allocator<int>> v2(100);
-        int a[] = {1, 2, 3, 4, 5};
-        const int N = sizeof(a)/sizeof(a[0]);
-        std::list<int, min_allocator<int>>::iterator i = v.insert(next(v2.cbegin(), 10), input_iterator<const int*>(a),
-                                       input_iterator<const int*>(a+N));
-        assert(false);
-    }
 #endif
+}
+
+int main()
+{
+    test<std::list<int> >();
+#if TEST_STD_VER >= 11
+    test<std::list<int, min_allocator<int>>>();
 #endif
 }
diff --git a/test/std/containers/sequences/list/list.modifiers/insert_iter_rvalue.pass.cpp b/test/std/containers/sequences/list/list.modifiers/insert_iter_rvalue.pass.cpp
index 3d5dec299b95..5d579fcd202e 100644
--- a/test/std/containers/sequences/list/list.modifiers/insert_iter_rvalue.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/insert_iter_rvalue.pass.cpp
@@ -7,14 +7,12 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <list>
 
 // iterator insert(const_iterator position, value_type&& x);
 
-#if _LIBCPP_DEBUG >= 1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
-#endif
-
 #include <list>
 #include <cassert>
 
@@ -23,7 +21,6 @@
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
     std::list<MoveOnly> l1;
     l1.insert(l1.cend(), MoveOnly(1));
@@ -34,17 +31,6 @@ int main()
     assert(l1.front() == MoveOnly(2));
     assert(l1.back() == MoveOnly(1));
     }
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#if _LIBCPP_DEBUG >= 1
-    {
-        std::list<int> v1(3);
-        std::list<int> v2(3);
-        v1.insert(v2.begin(), 4);
-        assert(false);
-    }
-#endif
-#if __cplusplus >= 201103L
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
     std::list<MoveOnly, min_allocator<MoveOnly>> l1;
     l1.insert(l1.cend(), MoveOnly(1));
@@ -55,14 +41,4 @@ int main()
     assert(l1.front() == MoveOnly(2));
     assert(l1.back() == MoveOnly(1));
     }
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#if _LIBCPP_DEBUG >= 1
-    {
-        std::list<int, min_allocator<int>> v1(3);
-        std::list<int, min_allocator<int>> v2(3);
-        v1.insert(v2.begin(), 4);
-        assert(false);
-    }
-#endif
-#endif
 }
diff --git a/test/std/containers/sequences/list/list.modifiers/insert_iter_size_value.pass.cpp b/test/std/containers/sequences/list/list.modifiers/insert_iter_size_value.pass.cpp
index c0f6ed198751..d85c1f4b9987 100644
--- a/test/std/containers/sequences/list/list.modifiers/insert_iter_size_value.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/insert_iter_size_value.pass.cpp
@@ -14,75 +14,23 @@
 
 // UNSUPPORTED: sanitizer-new-delete
 
-#if _LIBCPP_DEBUG >= 1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
-#endif
-
 #include <list>
 #include <cstdlib>
 #include <cassert>
 
 #include "min_allocator.h"
+#include "count_new.hpp"
 
-int throw_next = 0xFFFF;
-int count = 0;
-
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    if (throw_next == 0)
-        throw std::bad_alloc();
-    --throw_next;
-    ++count;
-    return std::malloc(s);
-}
-
-void  operator delete(void* p) throw()
-{
-    --count;
-    std::free(p);
-}
-
-int main()
-{
-    {
-    int a1[] = {1, 2, 3};
-    int a2[] = {1, 4, 4, 4, 4, 4, 2, 3};
-    std::list<int> l1(a1, a1+3);
-    std::list<int>::iterator i = l1.insert(next(l1.cbegin()), 5, 4);
-    assert(i == next(l1.begin()));
-    assert(l1 == std::list<int>(a2, a2+8));
-    throw_next = 4;
-    int save_count = count;
-    try
-    {
-        i = l1.insert(i, 5, 5);
-        assert(false);
-    }
-    catch (...)
-    {
-    }
-    throw_next = 0xFFFF;
-    assert(save_count == count);
-    assert(l1 == std::list<int>(a2, a2+8));
-    }
-#if _LIBCPP_DEBUG >= 1
-    {
-        std::list<int> c1(100);
-        std::list<int> c2;
-        std::list<int>::iterator i = c1.insert(next(c2.cbegin(), 10), 5, 1);
-        assert(false);
-    }
-#endif
-#if __cplusplus >= 201103L
-    {
+template <class List>
+void test() {
     int a1[] = {1, 2, 3};
     int a2[] = {1, 4, 4, 4, 4, 4, 2, 3};
-    std::list<int, min_allocator<int>> l1(a1, a1+3);
-    std::list<int, min_allocator<int>>::iterator i = l1.insert(next(l1.cbegin()), 5, 4);
+    List l1(a1, a1+3);
+    typename List::iterator i = l1.insert(next(l1.cbegin()), 5, 4);
     assert(i == next(l1.begin()));
-    assert((l1 == std::list<int, min_allocator<int>>(a2, a2+8)));
-    throw_next = 4;
-    int save_count = count;
+    assert(l1 == List(a2, a2+8));
+    globalMemCounter.throw_after = 4;
+    int save_count = globalMemCounter.outstanding_new;
     try
     {
         i = l1.insert(i, 5, 5);
@@ -91,17 +39,14 @@ int main()
     catch (...)
     {
     }
-    throw_next = 0xFFFF;
-    assert(save_count == count);
-    assert((l1 == std::list<int, min_allocator<int>>(a2, a2+8)));
-    }
-#if _LIBCPP_DEBUG >= 1
-    {
-        std::list<int, min_allocator<int>> c1(100);
-        std::list<int, min_allocator<int>> c2;
-        std::list<int, min_allocator<int>>::iterator i = c1.insert(next(c2.cbegin(), 10), 5, 1);
-        assert(false);
-    }
-#endif
+    assert(globalMemCounter.checkOutstandingNewEq(save_count));
+    assert(l1 == List(a2, a2+8));
+}
+
+int main()
+{
+    test<std::list<int> >();
+#if TEST_STD_VER >= 11
+    test<std::list<int, min_allocator<int>>>();
 #endif
 }
diff --git a/test/std/containers/sequences/list/list.modifiers/insert_iter_value.pass.cpp b/test/std/containers/sequences/list/list.modifiers/insert_iter_value.pass.cpp
index 1aacb63e4a70..87a033be64e9 100644
--- a/test/std/containers/sequences/list/list.modifiers/insert_iter_value.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/insert_iter_value.pass.cpp
@@ -7,87 +7,33 @@
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <list>
 
 // iterator insert(const_iterator position, const value_type& x);
 
-// UNSUPPORTED: sanitizer-new-delete
-
-#if _LIBCPP_DEBUG >= 1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
-#endif
-
 #include <list>
 #include <cstdlib>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
+#include "count_new.hpp"
 
-int throw_next = 0xFFFF;
-int count = 0;
-
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    if (throw_next == 0)
-        throw std::bad_alloc();
-    --throw_next;
-    ++count;
-    return std::malloc(s);
-}
-
-void  operator delete(void* p) throw()
-{
-    --count;
-    std::free(p);
-}
-
-int main()
+template <class List>
+void test()
 {
-    {
-    int a1[] = {1, 2, 3};
-    int a2[] = {1, 4, 2, 3};
-    std::list<int> l1(a1, a1+3);
-    std::list<int>::iterator i = l1.insert(next(l1.cbegin()), 4);
-    assert(i == next(l1.begin()));
-    assert(l1.size() == 4);
-    assert(distance(l1.begin(), l1.end()) == 4);
-    assert(l1 == std::list<int>(a2, a2+4));
-    throw_next = 0;
-    int save_count = count;
-    try
-    {
-        i = l1.insert(i, 5);
-        assert(false);
-    }
-    catch (...)
-    {
-    }
-    throw_next = 0xFFFF;
-    assert(save_count == count);
-    assert(l1 == std::list<int>(a2, a2+4));
-    }
-#if _LIBCPP_DEBUG >= 1
-    {
-        std::list<int> v1(3);
-        std::list<int> v2(3);
-        int i = 4;
-        v1.insert(v2.begin(), i);
-        assert(false);
-    }
-#endif
-#if __cplusplus >= 201103L
-    {
     int a1[] = {1, 2, 3};
     int a2[] = {1, 4, 2, 3};
-    std::list<int, min_allocator<int>> l1(a1, a1+3);
-    std::list<int, min_allocator<int>>::iterator i = l1.insert(next(l1.cbegin()), 4);
+    List l1(a1, a1+3);
+    typename List::iterator i = l1.insert(next(l1.cbegin()), 4);
     assert(i == next(l1.begin()));
     assert(l1.size() == 4);
     assert(distance(l1.begin(), l1.end()) == 4);
-    assert((l1 == std::list<int, min_allocator<int>>(a2, a2+4)));
-    throw_next = 0;
-    int save_count = count;
+    assert(l1 == List(a2, a2+4));
+
+#if !defined(TEST_HAS_NO_EXCEPTIONS) && !defined(DISABLE_NEW_COUNT)
+    globalMemCounter.throw_after = 0;
+    int save_count = globalMemCounter.outstanding_new;
     try
     {
         i = l1.insert(i, 5);
@@ -96,18 +42,15 @@ int main()
     catch (...)
     {
     }
-    throw_next = 0xFFFF;
-    assert(save_count == count);
-    assert((l1 == std::list<int, min_allocator<int>>(a2, a2+4)));
-    }
-#if _LIBCPP_DEBUG >= 1
-    {
-        std::list<int, min_allocator<int>> v1(3);
-        std::list<int, min_allocator<int>> v2(3);
-        int i = 4;
-        v1.insert(v2.begin(), i);
-        assert(false);
-    }
+    assert(globalMemCounter.checkOutstandingNewEq(save_count));
+    assert(l1 == List(a2, a2+4));
 #endif
+}
+
+int main()
+{
+    test<std::list<int> >();
+#if TEST_STD_VER >= 11
+    test<std::list<int, min_allocator<int>>>();
 #endif
 }
diff --git a/test/std/containers/sequences/list/list.modifiers/pop_back.pass.cpp b/test/std/containers/sequences/list/list.modifiers/pop_back.pass.cpp
index 3add8518809c..c5b0277c6eff 100644
--- a/test/std/containers/sequences/list/list.modifiers/pop_back.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/pop_back.pass.cpp
@@ -11,13 +11,10 @@
 
 // void pop_back();
 
-#if _LIBCPP_DEBUG >= 1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
-#endif
-
 #include <list>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 int main()
@@ -31,12 +28,8 @@ int main()
     assert(c == std::list<int>(a, a+1));
     c.pop_back();
     assert(c.empty());
-#if _LIBCPP_DEBUG >= 1
-        c.pop_back();
-        assert(false);
-#endif        
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     int a[] = {1, 2, 3};
     std::list<int, min_allocator<int>> c(a, a+3);
@@ -46,10 +39,6 @@ int main()
     assert((c == std::list<int, min_allocator<int>>(a, a+1)));
     c.pop_back();
     assert(c.empty());
-#if _LIBCPP_DEBUG >= 1
-        c.pop_back();
-        assert(false);
-#endif        
     }
 #endif
 }
diff --git a/test/std/containers/sequences/list/list.modifiers/pop_front.pass.cpp b/test/std/containers/sequences/list/list.modifiers/pop_front.pass.cpp
index aec17cc08f43..bb3ad546984d 100644
--- a/test/std/containers/sequences/list/list.modifiers/pop_front.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/pop_front.pass.cpp
@@ -28,7 +28,7 @@ int main()
     c.pop_front();
     assert(c.empty());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     int a[] = {1, 2, 3};
     std::list<int, min_allocator<int>> c(a, a+3);
diff --git a/test/std/containers/sequences/list/list.modifiers/push_back.pass.cpp b/test/std/containers/sequences/list/list.modifiers/push_back.pass.cpp
index 2638c541fa1c..3b05cd72968e 100644
--- a/test/std/containers/sequences/list/list.modifiers/push_back.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/push_back.pass.cpp
@@ -25,7 +25,7 @@ int main()
     int a[] = {0, 1, 2, 3, 4};
     assert(c == std::list<int>(a, a+5));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     std::list<int, min_allocator<int>> c;
     for (int i = 0; i < 5; ++i)
diff --git a/test/std/containers/sequences/list/list.modifiers/push_back_rvalue.pass.cpp b/test/std/containers/sequences/list/list.modifiers/push_back_rvalue.pass.cpp
index a2837f813bea..10acede511f4 100644
--- a/test/std/containers/sequences/list/list.modifiers/push_back_rvalue.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/push_back_rvalue.pass.cpp
@@ -30,7 +30,7 @@ int main()
     assert(l1.front() == MoveOnly(1));
     assert(l1.back() == MoveOnly(2));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     std::list<MoveOnly, min_allocator<MoveOnly>> l1;
     l1.push_back(MoveOnly(1));
diff --git a/test/std/containers/sequences/list/list.modifiers/push_front.pass.cpp b/test/std/containers/sequences/list/list.modifiers/push_front.pass.cpp
index b7f4febcd385..ed0ef662031a 100644
--- a/test/std/containers/sequences/list/list.modifiers/push_front.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/push_front.pass.cpp
@@ -25,7 +25,7 @@ int main()
     int a[] = {4, 3, 2, 1, 0};
     assert(c == std::list<int>(a, a+5));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     std::list<int, min_allocator<int>> c;
     for (int i = 0; i < 5; ++i)
diff --git a/test/std/containers/sequences/list/list.modifiers/push_front_rvalue.pass.cpp b/test/std/containers/sequences/list/list.modifiers/push_front_rvalue.pass.cpp
index 4f41c3dd390b..5321ee0faed3 100644
--- a/test/std/containers/sequences/list/list.modifiers/push_front_rvalue.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/push_front_rvalue.pass.cpp
@@ -30,7 +30,7 @@ int main()
     assert(l1.front() == MoveOnly(2));
     assert(l1.back() == MoveOnly(1));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     std::list<MoveOnly, min_allocator<MoveOnly>> l1;
     l1.push_front(MoveOnly(1));
diff --git a/test/std/containers/sequences/list/list.ops/merge.pass.cpp b/test/std/containers/sequences/list/list.ops/merge.pass.cpp
index d226ed5dc642..7c1287706f35 100644
--- a/test/std/containers/sequences/list/list.ops/merge.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/merge.pass.cpp
@@ -27,7 +27,7 @@ int main()
     c1.merge(c2);
     assert(c1 == std::list<int>(a3, a3+sizeof(a3)/sizeof(a3[0])));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     int a1[] = {1, 3, 7, 9, 10};
     int a2[] = {0, 2, 4, 5, 6, 8, 11};
diff --git a/test/std/containers/sequences/list/list.ops/merge_comp.pass.cpp b/test/std/containers/sequences/list/list.ops/merge_comp.pass.cpp
index ce861a5dcb88..838ff22b3a53 100644
--- a/test/std/containers/sequences/list/list.ops/merge_comp.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/merge_comp.pass.cpp
@@ -28,7 +28,7 @@ int main()
     c1.merge(c2, std::greater<int>());
     assert(c1 == std::list<int>(a3, a3+sizeof(a3)/sizeof(a3[0])));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     int a1[] = {10, 9, 7, 3, 1};
     int a2[] = {11, 8, 6, 5, 4, 2, 0};
diff --git a/test/std/containers/sequences/list/list.ops/remove.pass.cpp b/test/std/containers/sequences/list/list.ops/remove.pass.cpp
index f580c94ef486..fed28e442e12 100644
--- a/test/std/containers/sequences/list/list.ops/remove.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/remove.pass.cpp
@@ -57,7 +57,7 @@ int main()
         }
     assert ( it == c.end ());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     int a1[] = {1, 2, 3, 4};
     int a2[] = {1, 2, 4};
diff --git a/test/std/containers/sequences/list/list.ops/remove_if.pass.cpp b/test/std/containers/sequences/list/list.ops/remove_if.pass.cpp
index 162919ed85de..1b457823d6ab 100644
--- a/test/std/containers/sequences/list/list.ops/remove_if.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/remove_if.pass.cpp
@@ -50,7 +50,7 @@ int main()
     assert(c == std::list<int>(a2, a2+2));
     assert(cp.count() == 4);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     int a1[] = {1, 2, 3, 4};
     int a2[] = {3, 4};
diff --git a/test/std/containers/sequences/list/list.ops/reverse.pass.cpp b/test/std/containers/sequences/list/list.ops/reverse.pass.cpp
index 046453ae5386..120caba38ac9 100644
--- a/test/std/containers/sequences/list/list.ops/reverse.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/reverse.pass.cpp
@@ -25,7 +25,7 @@ int main()
     c1.reverse();
     assert(c1 == std::list<int>(a2, a2+sizeof(a2)/sizeof(a2[0])));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     int a1[] = {11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
     int a2[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
diff --git a/test/std/containers/sequences/list/list.ops/sort.pass.cpp b/test/std/containers/sequences/list/list.ops/sort.pass.cpp
index 1c11227237a7..d51aa92dd782 100644
--- a/test/std/containers/sequences/list/list.ops/sort.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/sort.pass.cpp
@@ -25,7 +25,7 @@ int main()
     c1.sort();
     assert(c1 == std::list<int>(a2, a2+sizeof(a2)/sizeof(a2[0])));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     int a1[] = {4, 8, 1, 0, 5, 7, 2, 3, 6, 11, 10, 9};
     int a2[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
diff --git a/test/std/containers/sequences/list/list.ops/sort_comp.pass.cpp b/test/std/containers/sequences/list/list.ops/sort_comp.pass.cpp
index 28125ab83c00..517eb62ccae2 100644
--- a/test/std/containers/sequences/list/list.ops/sort_comp.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/sort_comp.pass.cpp
@@ -26,7 +26,7 @@ int main()
     c1.sort(std::greater<int>());
     assert(c1 == std::list<int>(a2, a2+sizeof(a2)/sizeof(a2[0])));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     int a1[] = {4, 8, 1, 0, 5, 7, 2, 3, 6, 11, 10, 9};
     int a2[] = {11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
diff --git a/test/std/containers/sequences/list/list.ops/splice_pos_list.pass.cpp b/test/std/containers/sequences/list/list.ops/splice_pos_list.pass.cpp
index 354871c20afa..41d861da0d55 100644
--- a/test/std/containers/sequences/list/list.ops/splice_pos_list.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/splice_pos_list.pass.cpp
@@ -11,13 +11,10 @@
 
 // void splice(const_iterator position, list& x);
 
-#if _LIBCPP_DEBUG >= 1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
-#endif
-
 #include <list>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 int main()
@@ -403,15 +400,7 @@ int main()
         ++i;
         assert(*i == 6);
     }
-#if _LIBCPP_DEBUG >= 1
-    {
-        std::list<int> v1(3);
-        std::list<int> v2(3);
-        v1.splice(v2.begin(), v2);
-        assert(false);
-    }
-#endif
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::list<int, min_allocator<int>> l1;
         std::list<int, min_allocator<int>> l2;
@@ -791,13 +780,5 @@ int main()
         ++i;
         assert(*i == 6);
     }
-#if _LIBCPP_DEBUG >= 1
-    {
-        std::list<int, min_allocator<int>> v1(3);
-        std::list<int, min_allocator<int>> v2(3);
-        v1.splice(v2.begin(), v2);
-        assert(false);
-    }
-#endif
 #endif
 }
diff --git a/test/std/containers/sequences/list/list.ops/splice_pos_list_iter.pass.cpp b/test/std/containers/sequences/list/list.ops/splice_pos_list_iter.pass.cpp
index 5082c3f85175..427624a1cc3e 100644
--- a/test/std/containers/sequences/list/list.ops/splice_pos_list_iter.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/splice_pos_list_iter.pass.cpp
@@ -11,13 +11,10 @@
 
 // void splice(const_iterator position, list<T,Allocator>& x, iterator i);
 
-#if _LIBCPP_DEBUG >= 1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
-#endif
-
 #include <list>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 int main()
@@ -180,15 +177,7 @@ int main()
         ++i;
         assert(*i == 2);
     }
-#if _LIBCPP_DEBUG >= 1
-    {
-        std::list<int> v1(3);
-        std::list<int> v2(3);
-        v1.splice(v1.begin(), v2, v1.begin());
-        assert(false);
-    }
-#endif
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::list<int, min_allocator<int>> l1;
         std::list<int, min_allocator<int>> l2(a2, a2+1);
@@ -345,13 +334,5 @@ int main()
         ++i;
         assert(*i == 2);
     }
-#if _LIBCPP_DEBUG >= 1
-    {
-        std::list<int, min_allocator<int>> v1(3);
-        std::list<int, min_allocator<int>> v2(3);
-        v1.splice(v1.begin(), v2, v1.begin());
-        assert(false);
-    }
-#endif
 #endif
 }
diff --git a/test/std/containers/sequences/list/list.ops/splice_pos_list_iter_iter.pass.cpp b/test/std/containers/sequences/list/list.ops/splice_pos_list_iter_iter.pass.cpp
index fcc4acceec57..b7010636d20e 100644
--- a/test/std/containers/sequences/list/list.ops/splice_pos_list_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/splice_pos_list_iter_iter.pass.cpp
@@ -11,13 +11,10 @@
 
 // void splice(const_iterator position, list& x, iterator first, iterator last);
 
-#if _LIBCPP_DEBUG >= 1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
-#endif
-
 #include <list>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 int main()
@@ -120,15 +117,7 @@ int main()
         i = l2.begin();
         assert(*i == 4);
     }
-#if _LIBCPP_DEBUG >= 1
-    {
-        std::list<int> v1(3);
-        std::list<int> v2(3);
-        v1.splice(v1.begin(), v2, v2.begin(), v1.end());
-        assert(false);
-    }
-#endif
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::list<int, min_allocator<int>> l1(a1, a1+3);
         l1.splice(l1.begin(), l1, next(l1.begin()), next(l1.begin()));
@@ -225,13 +214,5 @@ int main()
         i = l2.begin();
         assert(*i == 4);
     }
-#if _LIBCPP_DEBUG >= 1
-    {
-        std::list<int, min_allocator<int>> v1(3);
-        std::list<int, min_allocator<int>> v2(3);
-        v1.splice(v1.begin(), v2, v2.begin(), v1.end());
-        assert(false);
-    }
-#endif
 #endif
 }
diff --git a/test/std/containers/sequences/list/list.ops/unique.pass.cpp b/test/std/containers/sequences/list/list.ops/unique.pass.cpp
index 48cad1ddd156..fa85b0eae77c 100644
--- a/test/std/containers/sequences/list/list.ops/unique.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/unique.pass.cpp
@@ -25,7 +25,7 @@ int main()
     c.unique();
     assert(c == std::list<int>(a2, a2+4));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     int a1[] = {2, 1, 1, 4, 4, 4, 4, 3, 3};
     int a2[] = {2, 1, 4, 3};
diff --git a/test/std/containers/sequences/list/list.ops/unique_pred.pass.cpp b/test/std/containers/sequences/list/list.ops/unique_pred.pass.cpp
index f8935b81f6a7..de6347d46f39 100644
--- a/test/std/containers/sequences/list/list.ops/unique_pred.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/unique_pred.pass.cpp
@@ -30,7 +30,7 @@ int main()
     c.unique(g);
     assert(c == std::list<int>(a2, a2+4));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     int a1[] = {2, 1, 1, 4, 4, 4, 4, 3, 3};
     int a2[] = {2, 1, 4, 3};
diff --git a/test/std/containers/sequences/list/list.special/db_swap_1.pass.cpp b/test/std/containers/sequences/list/list.special/db_swap_1.pass.cpp
deleted file mode 100644
index f7171795cd5f..000000000000
--- a/test/std/containers/sequences/list/list.special/db_swap_1.pass.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// <list>
-
-// template <class T, class Alloc>
-//   void swap(list<T,Alloc>& x, list<T,Alloc>& y);
-
-#if _LIBCPP_DEBUG >= 1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
-#endif
-
-#include <list>
-#include <cassert>
-
-#include <__debug>
-#include "min_allocator.h"
-
-int main()
-{
-#if _LIBCPP_DEBUG >= 1
-    {
-        int a1[] = {1, 3, 7, 9, 10};
-        int a2[] = {0, 2, 4, 5, 6, 8, 11};
-        std::list<int> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
-        std::list<int> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
-        std::list<int>::iterator i1 = c1.begin();
-        std::list<int>::iterator i2 = c2.begin();
-        swap(c1, c2);
-        c1.erase(i2);
-        c2.erase(i1);
-        std::list<int>::iterator j = i1;
-        c1.erase(i1);
-        assert(false);
-    }
-#if __cplusplus >= 201103L
-    {
-        int a1[] = {1, 3, 7, 9, 10};
-        int a2[] = {0, 2, 4, 5, 6, 8, 11};
-        std::list<int, min_allocator<int>> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
-        std::list<int, min_allocator<int>> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
-        std::list<int, min_allocator<int>>::iterator i1 = c1.begin();
-        std::list<int, min_allocator<int>>::iterator i2 = c2.begin();
-        swap(c1, c2);
-        c1.erase(i2);
-        c2.erase(i1);
-        std::list<int, min_allocator<int>>::iterator j = i1;
-        c1.erase(i1);
-        assert(false);
-    }
-#endif
-#endif
-}
diff --git a/test/std/containers/sequences/list/list.special/swap.pass.cpp b/test/std/containers/sequences/list/list.special/swap.pass.cpp
index bc5f4857edc7..54b262572ded 100644
--- a/test/std/containers/sequences/list/list.special/swap.pass.cpp
+++ b/test/std/containers/sequences/list/list.special/swap.pass.cpp
@@ -59,21 +59,18 @@ int main()
         assert(c2.empty());
         assert(distance(c2.begin(), c2.end()) == 0);
     }
-#ifndef _LIBCPP_DEBUG_LEVEL
-// This test known to result in undefined behavior detected by _LIBCPP_DEBUG_LEVEL >= 1
     {
         int a1[] = {1, 3, 7, 9, 10};
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
         typedef test_allocator<int> A;
         std::list<int, A> c1(a1, a1+sizeof(a1)/sizeof(a1[0]), A(1));
-        std::list<int, A> c2(a2, a2+sizeof(a2)/sizeof(a2[0]), A(2));
+        std::list<int, A> c2(a2, a2+sizeof(a2)/sizeof(a2[0]), A(1));
         swap(c1, c2);
         assert((c1 == std::list<int, A>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
         assert(c1.get_allocator() == A(1));
         assert((c2 == std::list<int, A>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
-        assert(c2.get_allocator() == A(2));
+        assert(c2.get_allocator() == A(1));
     }
-#endif
     {
         int a1[] = {1, 3, 7, 9, 10};
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
@@ -86,7 +83,7 @@ int main()
         assert((c2 == std::list<int, A>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
         assert(c2.get_allocator() == A(1));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         int a1[] = {1, 3, 7, 9, 10};
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
@@ -127,8 +124,6 @@ int main()
         assert(c2.empty());
         assert(distance(c2.begin(), c2.end()) == 0);
     }
-#ifndef _LIBCPP_DEBUG_LEVEL
-// This test known to result in undefined behavior detected by _LIBCPP_DEBUG_LEVEL >= 1
     {
         int a1[] = {1, 3, 7, 9, 10};
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
@@ -142,5 +137,4 @@ int main()
         assert(c2.get_allocator() == A());
     }
 #endif
-#endif
 }
diff --git a/test/std/containers/sequences/list/list.special/swap_noexcept.pass.cpp b/test/std/containers/sequences/list/list.special/swap_noexcept.pass.cpp
index 9c83ad58fed4..820da4c78f81 100644
--- a/test/std/containers/sequences/list/list.special/swap_noexcept.pass.cpp
+++ b/test/std/containers/sequences/list/list.special/swap_noexcept.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <list>
 
 // void swap(list& c)
@@ -21,6 +23,7 @@
 #include <list>
 #include <cassert>
 
+#include "test_macros.h"
 #include "MoveOnly.h"
 #include "test_allocator.h"
 
@@ -28,7 +31,7 @@ template <class T>
 struct some_alloc
 {
     typedef T value_type;
-    
+
     some_alloc() {}
     some_alloc(const some_alloc&);
     void deallocate(void*, unsigned) {}
@@ -40,7 +43,7 @@ template <class T>
 struct some_alloc2
 {
     typedef T value_type;
-    
+
     some_alloc2() {}
     some_alloc2(const some_alloc2&);
     void deallocate(void*, unsigned) {}
@@ -51,7 +54,6 @@ struct some_alloc2
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::list<MoveOnly> C;
         C c1, c2;
@@ -86,5 +88,4 @@ int main()
     }
 #endif
 
-#endif
 }
diff --git a/test/std/containers/sequences/list/types.pass.cpp b/test/std/containers/sequences/list/types.pass.cpp
index 77303601ae97..7d5f5b6fa2f0 100644
--- a/test/std/containers/sequences/list/types.pass.cpp
+++ b/test/std/containers/sequences/list/types.pass.cpp
@@ -31,18 +31,39 @@ struct A { std::list<A> v; }; // incomplete type support
 
 int main()
 {
-    static_assert((std::is_same<std::list<int>::value_type, int>::value), "");
-    static_assert((std::is_same<std::list<int>::allocator_type, std::allocator<int> >::value), "");
-    static_assert((std::is_same<std::list<int>::reference, std::allocator<int>::reference>::value), "");
-    static_assert((std::is_same<std::list<int>::const_reference, std::allocator<int>::const_reference>::value), "");
-    static_assert((std::is_same<std::list<int>::pointer, std::allocator<int>::pointer>::value), "");
-    static_assert((std::is_same<std::list<int>::const_pointer, std::allocator<int>::const_pointer>::value), "");
-#if __cplusplus >= 201103L
-    static_assert((std::is_same<std::list<int, min_allocator<int>>::value_type, int>::value), "");
-    static_assert((std::is_same<std::list<int, min_allocator<int>>::allocator_type, min_allocator<int> >::value), "");
-    static_assert((std::is_same<std::list<int, min_allocator<int>>::reference, int&>::value), "");
-    static_assert((std::is_same<std::list<int, min_allocator<int>>::const_reference, const int&>::value), "");
-    static_assert((std::is_same<std::list<int, min_allocator<int>>::pointer, min_pointer<int>>::value), "");
-    static_assert((std::is_same<std::list<int, min_allocator<int>>::const_pointer, min_pointer<const int>>::value), "");
+	{
+	typedef std::list<int> C;
+    static_assert((std::is_same<C::value_type, int>::value), "");
+    static_assert((std::is_same<C::allocator_type, std::allocator<int> >::value), "");
+    static_assert((std::is_same<C::reference, std::allocator<int>::reference>::value), "");
+    static_assert((std::is_same<C::const_reference, std::allocator<int>::const_reference>::value), "");
+    static_assert((std::is_same<C::pointer, std::allocator<int>::pointer>::value), "");
+    static_assert((std::is_same<C::const_pointer, std::allocator<int>::const_pointer>::value), "");
+
+    static_assert((std::is_signed<typename C::difference_type>::value), "");
+    static_assert((std::is_unsigned<typename C::size_type>::value), "");
+    static_assert((std::is_same<typename C::difference_type,
+        typename std::iterator_traits<typename C::iterator>::difference_type>::value), "");
+    static_assert((std::is_same<typename C::difference_type,
+        typename std::iterator_traits<typename C::const_iterator>::difference_type>::value), "");
+	}
+
+#if TEST_STD_VER >= 11
+    {
+	typedef std::list<int, min_allocator<int>> C;
+    static_assert((std::is_same<C::value_type, int>::value), "");
+    static_assert((std::is_same<C::allocator_type, min_allocator<int> >::value), "");
+    static_assert((std::is_same<C::reference, int&>::value), "");
+    static_assert((std::is_same<C::const_reference, const int&>::value), "");
+    static_assert((std::is_same<C::pointer, min_pointer<int>>::value), "");
+    static_assert((std::is_same<C::const_pointer, min_pointer<const int>>::value), "");
+
+    static_assert((std::is_signed<typename C::difference_type>::value), "");
+    static_assert((std::is_unsigned<typename C::size_type>::value), "");
+    static_assert((std::is_same<typename C::difference_type,
+        typename std::iterator_traits<typename C::iterator>::difference_type>::value), "");
+    static_assert((std::is_same<typename C::difference_type,
+        typename std::iterator_traits<typename C::const_iterator>::difference_type>::value), "");
+    }
 #endif
 }
diff --git a/test/std/containers/sequences/vector.bool/assign_copy.pass.cpp b/test/std/containers/sequences/vector.bool/assign_copy.pass.cpp
index 9501799ae3d0..54b7e84bb092 100644
--- a/test/std/containers/sequences/vector.bool/assign_copy.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/assign_copy.pass.cpp
@@ -19,22 +19,22 @@
 int main()
 {
     {
-        std::vector<bool, test_allocator<bool> > l(3, 2, test_allocator<bool>(5));
+        std::vector<bool, test_allocator<bool> > l(3, true, test_allocator<bool>(5));
         std::vector<bool, test_allocator<bool> > l2(l, test_allocator<bool>(3));
         l2 = l;
         assert(l2 == l);
         assert(l2.get_allocator() == test_allocator<bool>(3));
     }
     {
-        std::vector<bool, other_allocator<bool> > l(3, 2, other_allocator<bool>(5));
+        std::vector<bool, other_allocator<bool> > l(3, true, other_allocator<bool>(5));
         std::vector<bool, other_allocator<bool> > l2(l, other_allocator<bool>(3));
         l2 = l;
         assert(l2 == l);
         assert(l2.get_allocator() == other_allocator<bool>(5));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
-        std::vector<bool, min_allocator<bool> > l(3, 2, min_allocator<bool>());
+        std::vector<bool, min_allocator<bool> > l(3, true, min_allocator<bool>());
         std::vector<bool, min_allocator<bool> > l2(l, min_allocator<bool>());
         l2 = l;
         assert(l2 == l);
diff --git a/test/std/containers/sequences/vector.bool/assign_initializer_list.pass.cpp b/test/std/containers/sequences/vector.bool/assign_initializer_list.pass.cpp
index 2925fbc66745..ac7a2ce38adf 100644
--- a/test/std/containers/sequences/vector.bool/assign_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/assign_initializer_list.pass.cpp
@@ -28,7 +28,7 @@ int main()
     assert(d[2] == false);
     assert(d[3] == true);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     std::vector<bool, min_allocator<bool>> d;
     d.assign({true, false, false, true});
diff --git a/test/std/containers/sequences/vector.bool/assign_move.pass.cpp b/test/std/containers/sequences/vector.bool/assign_move.pass.cpp
index df98c817fd59..f07c1d90059d 100644
--- a/test/std/containers/sequences/vector.bool/assign_move.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/assign_move.pass.cpp
@@ -61,7 +61,7 @@ int main()
         assert(l.empty());
         assert(l2.get_allocator() == lo.get_allocator());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<bool, min_allocator<bool> > l(min_allocator<bool>{});
         std::vector<bool, min_allocator<bool> > lo(min_allocator<bool>{});
diff --git a/test/std/containers/sequences/vector.bool/capacity.pass.cpp b/test/std/containers/sequences/vector.bool/capacity.pass.cpp
index 63bff25f9f9a..3cbb09fe4ef0 100644
--- a/test/std/containers/sequences/vector.bool/capacity.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/capacity.pass.cpp
@@ -29,7 +29,7 @@ int main()
         v.push_back(0);
         assert(v.capacity() >= 101);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<bool, min_allocator<bool>> v;
         assert(v.capacity() == 0);
diff --git a/test/std/containers/sequences/vector.bool/construct_default.pass.cpp b/test/std/containers/sequences/vector.bool/construct_default.pass.cpp
index 07824098fc6f..983d363d1940 100644
--- a/test/std/containers/sequences/vector.bool/construct_default.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/construct_default.pass.cpp
@@ -29,12 +29,12 @@ test0()
 	static_assert((noexcept(C()) == noexcept(typename C::allocator_type())), "" );
 #endif
     C c;
-    assert(c.__invariants());
+    LIBCPP_ASSERT(c.__invariants());
     assert(c.empty());
     assert(c.get_allocator() == typename C::allocator_type());
 #if TEST_STD_VER >= 11
     C c1 = {};
-    assert(c1.__invariants());
+    LIBCPP_ASSERT(c1.__invariants());
     assert(c1.empty());
     assert(c1.get_allocator() == typename C::allocator_type());
 #endif
@@ -50,7 +50,7 @@ test1(const typename C::allocator_type& a)
 	static_assert((noexcept(C(typename C::allocator_type())) == std::is_nothrow_copy_constructible<typename C::allocator_type>::value), "" );
 #endif
     C c(a);
-    assert(c.__invariants());
+    LIBCPP_ASSERT(c.__invariants());
     assert(c.empty());
     assert(c.get_allocator() == a);
 }
diff --git a/test/std/containers/sequences/vector.bool/construct_iter_iter.pass.cpp b/test/std/containers/sequences/vector.bool/construct_iter_iter.pass.cpp
index 94e6801825d8..3d11239702c9 100644
--- a/test/std/containers/sequences/vector.bool/construct_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/construct_iter_iter.pass.cpp
@@ -15,6 +15,7 @@
 #include <vector>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 
@@ -23,7 +24,7 @@ void
 test(Iterator first, Iterator last)
 {
     C c(first, last);
-    assert(c.__invariants());
+    LIBCPP_ASSERT(c.__invariants());
     assert(c.size() == std::distance(first, last));
     for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i, ++first)
         assert(*i == *first);
@@ -38,7 +39,7 @@ int main()
     test<std::vector<bool> >(bidirectional_iterator<const bool*>(a), bidirectional_iterator<const bool*>(an));
     test<std::vector<bool> >(random_access_iterator<const bool*>(a), random_access_iterator<const bool*>(an));
     test<std::vector<bool> >(a, an);
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test<std::vector<bool, min_allocator<bool>> >(input_iterator<const bool*>(a), input_iterator<const bool*>(an));
     test<std::vector<bool, min_allocator<bool>> >(forward_iterator<const bool*>(a), forward_iterator<const bool*>(an));
     test<std::vector<bool, min_allocator<bool>> >(bidirectional_iterator<const bool*>(a), bidirectional_iterator<const bool*>(an));
diff --git a/test/std/containers/sequences/vector.bool/construct_iter_iter_alloc.pass.cpp b/test/std/containers/sequences/vector.bool/construct_iter_iter_alloc.pass.cpp
index ea9d41d342f8..196694d73998 100644
--- a/test/std/containers/sequences/vector.bool/construct_iter_iter_alloc.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/construct_iter_iter_alloc.pass.cpp
@@ -16,6 +16,7 @@
 #include <vector>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 
@@ -24,7 +25,7 @@ void
 test(Iterator first, Iterator last, const typename C::allocator_type& a)
 {
     C c(first, last, a);
-    assert(c.__invariants());
+    LIBCPP_ASSERT(c.__invariants());
     assert(c.size() == std::distance(first, last));
     for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i, ++first)
         assert(*i == *first);
@@ -42,7 +43,7 @@ int main()
     test<std::vector<bool> >(random_access_iterator<const bool*>(a), random_access_iterator<const bool*>(an), alloc);
     test<std::vector<bool> >(a, an, alloc);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     min_allocator<bool> alloc;
     test<std::vector<bool, min_allocator<bool>> >(input_iterator<const bool*>(a), input_iterator<const bool*>(an), alloc);
diff --git a/test/std/containers/sequences/vector.bool/construct_size.pass.cpp b/test/std/containers/sequences/vector.bool/construct_size.pass.cpp
index 93ecbe87c380..271e4ee33aa4 100644
--- a/test/std/containers/sequences/vector.bool/construct_size.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/construct_size.pass.cpp
@@ -15,22 +15,22 @@
 #include <vector>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 #include "test_allocator.h"
 
 template <class C>
 void
-test2(typename C::size_type n, typename C::allocator_type const& a = typename C::allocator_type ())
+test2(typename C::size_type n,
+      typename C::allocator_type const& a = typename C::allocator_type ())
 {
-#if _LIBCPP_STD_VER > 11
+#if TEST_STD_VER >= 14
     C c(n, a);
-    assert(c.__invariants());
+    LIBCPP_ASSERT(c.__invariants());
     assert(c.size() == n);
     assert(c.get_allocator() == a);
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i)
         assert(*i == typename C::value_type());
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 #endif
 }
 
@@ -39,7 +39,7 @@ void
 test1(typename C::size_type n)
 {
     C c(n);
-    assert(c.__invariants());
+    LIBCPP_ASSERT(c.__invariants());
     assert(c.size() == n);
     assert(c.get_allocator() == typename C::allocator_type());
     for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i)
@@ -57,7 +57,7 @@ test(typename C::size_type n)
 int main()
 {
     test<std::vector<bool> >(50);
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test<std::vector<bool, min_allocator<bool>> >(50);
     test2<std::vector<bool, test_allocator<bool>> >( 100, test_allocator<bool>(23));
 #endif
diff --git a/test/std/containers/sequences/vector.bool/construct_size_value.pass.cpp b/test/std/containers/sequences/vector.bool/construct_size_value.pass.cpp
index fc772f10dfc4..c66fd4972899 100644
--- a/test/std/containers/sequences/vector.bool/construct_size_value.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/construct_size_value.pass.cpp
@@ -15,6 +15,7 @@
 #include <vector>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class C>
@@ -22,7 +23,7 @@ void
 test(typename C::size_type n, const typename C::value_type& x)
 {
     C c(n, x);
-    assert(c.__invariants());
+    LIBCPP_ASSERT(c.__invariants());
     assert(c.size() == n);
     for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i)
         assert(*i == x);
@@ -30,8 +31,8 @@ test(typename C::size_type n, const typename C::value_type& x)
 
 int main()
 {
-    test<std::vector<bool> >(50, 3);
-#if __cplusplus >= 201103L
-    test<std::vector<bool, min_allocator<bool>> >(50, 3);
+    test<std::vector<bool> >(50, true);
+#if TEST_STD_VER >= 11
+    test<std::vector<bool, min_allocator<bool>> >(50, true);
 #endif
 }
diff --git a/test/std/containers/sequences/vector.bool/construct_size_value_alloc.pass.cpp b/test/std/containers/sequences/vector.bool/construct_size_value_alloc.pass.cpp
index 6cca948ed834..2ef501271f52 100644
--- a/test/std/containers/sequences/vector.bool/construct_size_value_alloc.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/construct_size_value_alloc.pass.cpp
@@ -15,6 +15,7 @@
 #include <vector>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class C>
@@ -23,7 +24,7 @@ test(typename C::size_type n, const typename C::value_type& x,
      const typename C::allocator_type& a)
 {
     C c(n, x, a);
-    assert(c.__invariants());
+    LIBCPP_ASSERT(c.__invariants());
     assert(a == c.get_allocator());
     assert(c.size() == n);
     for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i)
@@ -32,8 +33,8 @@ test(typename C::size_type n, const typename C::value_type& x,
 
 int main()
 {
-    test<std::vector<bool> >(50, 3, std::allocator<bool>());
-#if __cplusplus >= 201103L
-    test<std::vector<bool, min_allocator<bool>> >(50, 3, min_allocator<bool>());
+    test<std::vector<bool> >(50, true, std::allocator<bool>());
+#if TEST_STD_VER >= 11
+    test<std::vector<bool, min_allocator<bool>> >(50, true, min_allocator<bool>());
 #endif
 }
diff --git a/test/std/containers/sequences/vector.bool/copy.pass.cpp b/test/std/containers/sequences/vector.bool/copy.pass.cpp
index 58822782ff8b..b3cf9b551f96 100644
--- a/test/std/containers/sequences/vector.bool/copy.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/copy.pass.cpp
@@ -14,6 +14,8 @@
 
 #include <vector>
 #include <cassert>
+
+#include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
@@ -23,7 +25,7 @@ test(const C& x)
 {
     unsigned s = x.size();
     C c(x);
-    assert(c.__invariants());
+    LIBCPP_ASSERT(c.__invariants());
     assert(c.size() == s);
     assert(c == x);
 }
@@ -36,27 +38,25 @@ int main()
         test(std::vector<bool>(a, an));
     }
     {
-        std::vector<bool, test_allocator<bool> > v(3, 2, test_allocator<bool>(5));
+        std::vector<bool, test_allocator<bool> > v(3, true, test_allocator<bool>(5));
         std::vector<bool, test_allocator<bool> > v2 = v;
         assert(v2 == v);
         assert(v2.get_allocator() == v.get_allocator());
     }
-#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#if TEST_STD_VER >= 11
     {
-        std::vector<bool, other_allocator<bool> > v(3, 2, other_allocator<bool>(5));
+        std::vector<bool, other_allocator<bool> > v(3, true, other_allocator<bool>(5));
         std::vector<bool, other_allocator<bool> > v2 = v;
         assert(v2 == v);
         assert(v2.get_allocator() == other_allocator<bool>(-2));
     }
-#endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
-#if __cplusplus >= 201103L
     {
         bool a[] = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
         bool* an = a + sizeof(a)/sizeof(a[0]);
         test(std::vector<bool, min_allocator<bool>>(a, an));
     }
     {
-        std::vector<bool, min_allocator<bool> > v(3, 2, min_allocator<bool>());
+        std::vector<bool, min_allocator<bool> > v(3, true, min_allocator<bool>());
         std::vector<bool, min_allocator<bool> > v2 = v;
         assert(v2 == v);
         assert(v2.get_allocator() == v.get_allocator());
diff --git a/test/std/containers/sequences/vector.bool/copy_alloc.pass.cpp b/test/std/containers/sequences/vector.bool/copy_alloc.pass.cpp
index 2f0192b995ad..aa8646a9b819 100644
--- a/test/std/containers/sequences/vector.bool/copy_alloc.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/copy_alloc.pass.cpp
@@ -13,6 +13,8 @@
 
 #include <vector>
 #include <cassert>
+
+#include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
@@ -22,7 +24,7 @@ test(const C& x, const typename C::allocator_type& a)
 {
     unsigned s = x.size();
     C c(x, a);
-    assert(c.__invariants());
+    LIBCPP_ASSERT(c.__invariants());
     assert(c.size() == s);
     assert(c == x);
 }
@@ -30,30 +32,30 @@ test(const C& x, const typename C::allocator_type& a)
 int main()
 {
     {
-        int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 1, 0};
-        int* an = a + sizeof(a)/sizeof(a[0]);
+        bool a[] = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
+        bool* an = a + sizeof(a)/sizeof(a[0]);
         test(std::vector<bool>(a, an), std::allocator<bool>());
     }
     {
-        std::vector<bool, test_allocator<bool> > l(3, 2, test_allocator<bool>(5));
+        std::vector<bool, test_allocator<bool> > l(3, true, test_allocator<bool>(5));
         std::vector<bool, test_allocator<bool> > l2(l, test_allocator<bool>(3));
         assert(l2 == l);
         assert(l2.get_allocator() == test_allocator<bool>(3));
     }
     {
-        std::vector<bool, other_allocator<bool> > l(3, 2, other_allocator<bool>(5));
+        std::vector<bool, other_allocator<bool> > l(3, true, other_allocator<bool>(5));
         std::vector<bool, other_allocator<bool> > l2(l, other_allocator<bool>(3));
         assert(l2 == l);
         assert(l2.get_allocator() == other_allocator<bool>(3));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
-        int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 1, 0};
-        int* an = a + sizeof(a)/sizeof(a[0]);
+        bool a[] = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
+        bool* an = a + sizeof(a)/sizeof(a[0]);
         test(std::vector<bool, min_allocator<bool>>(a, an), min_allocator<bool>());
     }
     {
-        std::vector<bool, min_allocator<bool> > l(3, 2, min_allocator<bool>());
+        std::vector<bool, min_allocator<bool> > l(3, true, min_allocator<bool>());
         std::vector<bool, min_allocator<bool> > l2(l, min_allocator<bool>());
         assert(l2 == l);
         assert(l2.get_allocator() == min_allocator<bool>());
diff --git a/test/std/containers/sequences/vector.bool/default_noexcept.pass.cpp b/test/std/containers/sequences/vector.bool/default_noexcept.pass.cpp
index b94588ead93b..4f860dabac95 100644
--- a/test/std/containers/sequences/vector.bool/default_noexcept.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/default_noexcept.pass.cpp
@@ -14,9 +14,12 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <vector>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_allocator.h"
 
 template <class T>
@@ -28,14 +31,13 @@ struct some_alloc
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::vector<bool> C;
-        static_assert(std::is_nothrow_default_constructible<C>::value, "");
+        LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
     }
     {
         typedef std::vector<bool, test_allocator<bool>> C;
-        static_assert(std::is_nothrow_default_constructible<C>::value, "");
+        LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
     }
     {
         typedef std::vector<bool, other_allocator<bool>> C;
@@ -45,5 +47,4 @@ int main()
         typedef std::vector<bool, some_alloc<bool>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/sequences/vector.bool/dtor_noexcept.pass.cpp b/test/std/containers/sequences/vector.bool/dtor_noexcept.pass.cpp
index 682e74ef03c2..bd2534ad3de7 100644
--- a/test/std/containers/sequences/vector.bool/dtor_noexcept.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/dtor_noexcept.pass.cpp
@@ -11,13 +11,13 @@
 
 // ~vector<bool>() // implied noexcept;
 
+// UNSUPPORTED: c++98, c++03
+
 #include <vector>
 #include <cassert>
 
 #include "test_allocator.h"
 
-#if __has_feature(cxx_noexcept)
-
 template <class T>
 struct some_alloc
 {
@@ -26,11 +26,8 @@ struct some_alloc
     ~some_alloc() noexcept(false);
 };
 
-#endif
-
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::vector<bool> C;
         static_assert(std::is_nothrow_destructible<C>::value, "");
@@ -47,5 +44,4 @@ int main()
         typedef std::vector<bool, some_alloc<bool>> C;
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/sequences/vector.bool/emplace.pass.cpp b/test/std/containers/sequences/vector.bool/emplace.pass.cpp
index f3fd1e9926f0..ccdce913c73c 100644
--- a/test/std/containers/sequences/vector.bool/emplace.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/emplace.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <vector>
 //  vector<bool>
 
@@ -18,11 +19,10 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     {
         typedef std::vector<bool> C;
         C c;
-        
+
         C::iterator i = c.emplace(c.cbegin());
         assert(i == c.begin());
         assert(c.size() == 1);
@@ -64,5 +64,4 @@ int main()
         assert(c[1] == true);
         assert(c.back() == true);
     }
-#endif
 }
diff --git a/test/std/containers/sequences/vector.bool/emplace_back.pass.cpp b/test/std/containers/sequences/vector.bool/emplace_back.pass.cpp
index 57aa47822f8a..2950ee3882f1 100644
--- a/test/std/containers/sequences/vector.bool/emplace_back.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/emplace_back.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <vector>
 //  vector.bool
 
@@ -19,7 +20,6 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     {
         typedef std::vector<bool> C;
         C c;
@@ -39,7 +39,7 @@ int main()
     {
         typedef std::vector<bool, min_allocator<bool>> C;
         C c;
-        
+
         c.emplace_back();
         assert(c.size() == 1);
         assert(c.front() == false);
@@ -53,5 +53,4 @@ int main()
         assert(c[1] == true);
         assert(c.back() == true);
     }
-#endif
 }
diff --git a/test/std/containers/sequences/vector.bool/erase_iter.pass.cpp b/test/std/containers/sequences/vector.bool/erase_iter.pass.cpp
index cbf26dd570a5..04e3dd7c25f1 100644
--- a/test/std/containers/sequences/vector.bool/erase_iter.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/erase_iter.pass.cpp
@@ -40,7 +40,7 @@ int main()
     assert(l1.size() == 0);
     assert(distance(l1.begin(), l1.end()) == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     std::vector<bool, min_allocator<bool>> l1(a1, a1+3);
     std::vector<bool, min_allocator<bool>>::const_iterator i = l1.begin();
diff --git a/test/std/containers/sequences/vector.bool/erase_iter_iter.pass.cpp b/test/std/containers/sequences/vector.bool/erase_iter_iter.pass.cpp
index 2c2c4cc48616..2b9f0e31c2fa 100644
--- a/test/std/containers/sequences/vector.bool/erase_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/erase_iter_iter.pass.cpp
@@ -50,7 +50,7 @@ int main()
         assert(distance(l1.cbegin(), l1.cend()) == 0);
         assert(i == l1.begin());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<bool, min_allocator<bool>> l1(a1, a1+3);
         std::vector<bool, min_allocator<bool>>::iterator i = l1.erase(l1.cbegin(), l1.cbegin());
diff --git a/test/std/containers/sequences/vector.bool/initializer_list.pass.cpp b/test/std/containers/sequences/vector.bool/initializer_list.pass.cpp
index b9b468654497..07bae0eb7089 100644
--- a/test/std/containers/sequences/vector.bool/initializer_list.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/initializer_list.pass.cpp
@@ -27,7 +27,7 @@ int main()
     assert(d[2] == false);
     assert(d[3] == true);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     std::vector<bool, min_allocator<bool>> d = {true, false, false, true};
     assert(d.size() == 4);
diff --git a/test/std/containers/sequences/vector.bool/initializer_list_alloc.pass.cpp b/test/std/containers/sequences/vector.bool/initializer_list_alloc.pass.cpp
index aea3ad763cde..5f7f5144f841 100644
--- a/test/std/containers/sequences/vector.bool/initializer_list_alloc.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/initializer_list_alloc.pass.cpp
@@ -29,7 +29,7 @@ int main()
     assert(d[2] == false);
     assert(d[3] == true);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     std::vector<bool, min_allocator<bool>> d({true, false, false, true}, min_allocator<bool>());
     assert(d.get_allocator() == min_allocator<bool>());
diff --git a/test/std/containers/sequences/vector.bool/insert_iter_initializer_list.pass.cpp b/test/std/containers/sequences/vector.bool/insert_iter_initializer_list.pass.cpp
index c081cc81c592..3a176d94e860 100644
--- a/test/std/containers/sequences/vector.bool/insert_iter_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/insert_iter_initializer_list.pass.cpp
@@ -39,7 +39,7 @@ int main()
     assert(d[12] == true);
     assert(d[13] == true);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     std::vector<bool, min_allocator<bool>> d(10, true);
     std::vector<bool, min_allocator<bool>>::iterator i = d.insert(d.cbegin() + 2, {false, true, true, false});
diff --git a/test/std/containers/sequences/vector.bool/insert_iter_iter_iter.pass.cpp b/test/std/containers/sequences/vector.bool/insert_iter_iter_iter.pass.cpp
index e51f8b589c7f..89fe7a76d409 100644
--- a/test/std/containers/sequences/vector.bool/insert_iter_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/insert_iter_iter_iter.pass.cpp
@@ -89,7 +89,7 @@ int main()
         for (; j < v.size(); ++j)
             assert(v[j] == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<bool, min_allocator<bool>> v(100);
         bool a[] = {1, 0, 0, 1, 1};
diff --git a/test/std/containers/sequences/vector.bool/insert_iter_size_value.pass.cpp b/test/std/containers/sequences/vector.bool/insert_iter_size_value.pass.cpp
index 710ad4885f09..35c57cbd8e42 100644
--- a/test/std/containers/sequences/vector.bool/insert_iter_size_value.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/insert_iter_size_value.pass.cpp
@@ -63,7 +63,7 @@ int main()
         for (++j; j < v.size(); ++j)
             assert(v[j] == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<bool, min_allocator<bool>> v(100);
         std::vector<bool, min_allocator<bool>>::iterator i = v.insert(v.cbegin() + 10, 5, 1);
diff --git a/test/std/containers/sequences/vector.bool/insert_iter_value.pass.cpp b/test/std/containers/sequences/vector.bool/insert_iter_value.pass.cpp
index 51c4626de0d0..78ffe7ba73cd 100644
--- a/test/std/containers/sequences/vector.bool/insert_iter_value.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/insert_iter_value.pass.cpp
@@ -60,7 +60,7 @@ int main()
         for (++j; j < v.size(); ++j)
             assert(v[j] == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<bool, min_allocator<bool>> v(100);
         std::vector<bool, min_allocator<bool>>::iterator i = v.insert(v.cbegin() + 10, 1);
diff --git a/test/std/containers/sequences/vector.bool/iterators.pass.cpp b/test/std/containers/sequences/vector.bool/iterators.pass.cpp
index c54fa4a80a95..882ac9be4a5d 100644
--- a/test/std/containers/sequences/vector.bool/iterators.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/iterators.pass.cpp
@@ -58,7 +58,7 @@ int main()
         C::iterator i;
         C::const_iterator j;
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef bool T;
         typedef std::vector<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/vector.bool/move.pass.cpp b/test/std/containers/sequences/vector.bool/move.pass.cpp
index e877292ced77..f3a11ec562c0 100644
--- a/test/std/containers/sequences/vector.bool/move.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/move.pass.cpp
@@ -45,7 +45,7 @@ int main()
         assert(l.empty());
         assert(l2.get_allocator() == lo.get_allocator());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<bool, min_allocator<bool> > l(min_allocator<bool>{});
         std::vector<bool, min_allocator<bool> > lo(min_allocator<bool>{});
diff --git a/test/std/containers/sequences/vector.bool/move_alloc.pass.cpp b/test/std/containers/sequences/vector.bool/move_alloc.pass.cpp
index deee93261971..7aaa7c55550b 100644
--- a/test/std/containers/sequences/vector.bool/move_alloc.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/move_alloc.pass.cpp
@@ -58,7 +58,7 @@ int main()
         assert(!l.empty());
         assert(l2.get_allocator() == other_allocator<bool>(4));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<bool, min_allocator<bool> > l(min_allocator<bool>{});
         std::vector<bool, min_allocator<bool> > lo(min_allocator<bool>{});
diff --git a/test/std/containers/sequences/vector.bool/move_assign_noexcept.pass.cpp b/test/std/containers/sequences/vector.bool/move_assign_noexcept.pass.cpp
index 4dd871c9447e..fe53fbfc17e0 100644
--- a/test/std/containers/sequences/vector.bool/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/move_assign_noexcept.pass.cpp
@@ -16,6 +16,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <vector>
 #include <cassert>
 
@@ -32,7 +34,7 @@ template <class T>
 struct some_alloc2
 {
     typedef T value_type;
-    
+
     some_alloc2() {}
     some_alloc2(const some_alloc2&);
     void deallocate(void*, unsigned) {}
@@ -45,7 +47,7 @@ template <class T>
 struct some_alloc3
 {
     typedef T value_type;
-    
+
     some_alloc3() {}
     some_alloc3(const some_alloc3&);
     void deallocate(void*, unsigned) {}
@@ -56,7 +58,6 @@ struct some_alloc3
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::vector<bool> C;
         static_assert(std::is_nothrow_move_assignable<C>::value, "");
@@ -87,6 +88,4 @@ int main()
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
 #endif
-
-#endif
 }
diff --git a/test/std/containers/sequences/vector.bool/move_noexcept.pass.cpp b/test/std/containers/sequences/vector.bool/move_noexcept.pass.cpp
index 132186b555f2..2153c7956bfc 100644
--- a/test/std/containers/sequences/vector.bool/move_noexcept.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/move_noexcept.pass.cpp
@@ -14,6 +14,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <vector>
 #include <cassert>
 
@@ -28,7 +30,6 @@ struct some_alloc
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::vector<bool> C;
         static_assert(std::is_nothrow_move_constructible<C>::value, "");
@@ -50,5 +51,4 @@ int main()
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
 #endif
     }
-#endif
 }
diff --git a/test/std/containers/sequences/vector.bool/op_equal_initializer_list.pass.cpp b/test/std/containers/sequences/vector.bool/op_equal_initializer_list.pass.cpp
index ef3dc5d10796..4b959cf00ad3 100644
--- a/test/std/containers/sequences/vector.bool/op_equal_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/op_equal_initializer_list.pass.cpp
@@ -28,7 +28,7 @@ int main()
     assert(d[2] == false);
     assert(d[3] == true);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     std::vector<bool, min_allocator<bool>> d;
     d = {true, false, false, true};
diff --git a/test/std/containers/sequences/vector.bool/push_back.pass.cpp b/test/std/containers/sequences/vector.bool/push_back.pass.cpp
index c6b0fbf41853..3897a438b445 100644
--- a/test/std/containers/sequences/vector.bool/push_back.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/push_back.pass.cpp
@@ -31,7 +31,7 @@ int main()
                 assert(c[j] == a[j]);
         }
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         bool a[] = {0, 1, 1, 0, 1, 0, 0};
         const unsigned N = sizeof(a)/sizeof(a[0]);
diff --git a/test/std/containers/sequences/vector.bool/reference.swap.pass.cpp b/test/std/containers/sequences/vector.bool/reference.swap.pass.cpp
new file mode 100644
index 000000000000..06351e418ac4
--- /dev/null
+++ b/test/std/containers/sequences/vector.bool/reference.swap.pass.cpp
@@ -0,0 +1,39 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <vector>
+// vector<bool>
+
+// static void swap(reference x, reference y) noexcept;
+
+#include <vector>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main()
+{
+
+    bool a[] = {false, true, false, true};
+    bool* an = a + sizeof(a)/sizeof(a[0]);
+
+	std::vector<bool> v(a, an);
+	std::vector<bool>::reference r1 = v[0];
+	std::vector<bool>::reference r2 = v[3];
+
+#if TEST_STD_VER >= 11
+    static_assert((noexcept(v.swap(r1,r2))), "");
+#endif
+
+	assert(!r1);
+	assert( r2);
+	v.swap(r1, r2);
+	assert( r1);
+	assert(!r2);
+}
diff --git a/test/std/containers/sequences/vector.bool/reserve.pass.cpp b/test/std/containers/sequences/vector.bool/reserve.pass.cpp
index be717a3be8a8..489ca95ee789 100644
--- a/test/std/containers/sequences/vector.bool/reserve.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/reserve.pass.cpp
@@ -34,7 +34,7 @@ int main()
         assert(v.size() == 100);
         assert(v.capacity() >= 150);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<bool, min_allocator<bool>> v;
         v.reserve(10);
diff --git a/test/std/containers/sequences/vector.bool/resize_size.pass.cpp b/test/std/containers/sequences/vector.bool/resize_size.pass.cpp
index f75720c94ea3..bc51e0bbba27 100644
--- a/test/std/containers/sequences/vector.bool/resize_size.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/resize_size.pass.cpp
@@ -32,7 +32,7 @@ int main()
         assert(v.size() == 300);
         assert(v.capacity() >= 400);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<bool, min_allocator<bool>> v(100);
         v.resize(50);
diff --git a/test/std/containers/sequences/vector.bool/resize_size_value.pass.cpp b/test/std/containers/sequences/vector.bool/resize_size_value.pass.cpp
index 8cecf44d2fb0..919000732698 100644
--- a/test/std/containers/sequences/vector.bool/resize_size_value.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/resize_size_value.pass.cpp
@@ -33,7 +33,7 @@ int main()
         for (unsigned i = 50; i < 200; ++i)
             assert(v[i] == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<bool, min_allocator<bool>> v(100);
         v.resize(50, 1);
diff --git a/test/std/containers/sequences/vector.bool/shrink_to_fit.pass.cpp b/test/std/containers/sequences/vector.bool/shrink_to_fit.pass.cpp
index 1f9fcac3d9bf..03997cbec71e 100644
--- a/test/std/containers/sequences/vector.bool/shrink_to_fit.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/shrink_to_fit.pass.cpp
@@ -26,7 +26,7 @@ int main()
         assert(v.capacity() >= 101);
         assert(v.size() >= 101);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<bool, min_allocator<bool>> v(100);
         v.push_back(1);
diff --git a/test/std/containers/sequences/vector.bool/swap.pass.cpp b/test/std/containers/sequences/vector.bool/swap.pass.cpp
index a92c6a6c165f..81af528f2a9a 100644
--- a/test/std/containers/sequences/vector.bool/swap.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/swap.pass.cpp
@@ -62,7 +62,7 @@ int main()
         assert(v[0] == false);
         assert(v[1] == true);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<bool, min_allocator<bool>> v1(100);
         std::vector<bool, min_allocator<bool>> v2(200);
diff --git a/test/std/containers/sequences/vector.bool/swap_noexcept.pass.cpp b/test/std/containers/sequences/vector.bool/swap_noexcept.pass.cpp
index 6f36473fa989..7ba44453b371 100644
--- a/test/std/containers/sequences/vector.bool/swap_noexcept.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/swap_noexcept.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <vector>
 
 // void swap(vector& c)
@@ -22,13 +24,14 @@
 #include <vector>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_allocator.h"
 
 template <class T>
 struct some_alloc
 {
     typedef T value_type;
-    
+
     some_alloc() {}
     some_alloc(const some_alloc&);
     void deallocate(void*, unsigned) {}
@@ -40,7 +43,7 @@ template <class T>
 struct some_alloc2
 {
     typedef T value_type;
-    
+
     some_alloc2() {}
     some_alloc2(const some_alloc2&);
     void deallocate(void*, unsigned) {}
@@ -51,7 +54,6 @@ struct some_alloc2
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::vector<bool> C;
         C c1, c2;
@@ -85,6 +87,4 @@ int main()
         static_assert( noexcept(swap(c1, c2)), "");
     }
 #endif
-
-#endif
 }
diff --git a/test/std/containers/sequences/vector.bool/types.pass.cpp b/test/std/containers/sequences/vector.bool/types.pass.cpp
index b266b3bbb927..4e8edc8891bd 100644
--- a/test/std/containers/sequences/vector.bool/types.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/types.pass.cpp
@@ -46,7 +46,15 @@ test()
     static_assert((std::is_same<typename C::allocator_type, Allocator>::value), "");
     static_assert((std::is_same<typename C::size_type, typename std::allocator_traits<Allocator>::size_type>::value), "");
     static_assert((std::is_same<typename C::difference_type, typename std::allocator_traits<Allocator>::difference_type>::value), "");
-    static_assert((std::is_same<
+
+    static_assert((std::is_signed<typename C::difference_type>::value), "");
+    static_assert((std::is_unsigned<typename C::size_type>::value), "");
+    static_assert((std::is_same<typename C::difference_type,
+        typename std::iterator_traits<typename C::iterator>::difference_type>::value), "");
+    static_assert((std::is_same<typename C::difference_type,
+        typename std::iterator_traits<typename C::const_iterator>::difference_type>::value), "");
+
+   static_assert((std::is_same<
         typename std::iterator_traits<typename C::iterator>::iterator_category,
         std::random_access_iterator_tag>::value), "");
     static_assert((std::is_same<
@@ -66,7 +74,7 @@ int main()
     test<std::allocator<bool> >();
     static_assert((std::is_same<std::vector<bool>::allocator_type,
                                 std::allocator<bool> >::value), "");
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test<min_allocator<bool> >();
 #endif
 }
diff --git a/test/std/containers/sequences/vector.bool/vector_bool.pass.cpp b/test/std/containers/sequences/vector.bool/vector_bool.pass.cpp
index a78f4fd590be..4f82792fa1fd 100644
--- a/test/std/containers/sequences/vector.bool/vector_bool.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/vector_bool.pass.cpp
@@ -31,18 +31,18 @@ int main()
     typedef std::hash<T> H;
     static_assert((std::is_same<H::argument_type, T>::value), "" );
     static_assert((std::is_same<H::result_type, std::size_t>::value), "" );
-    
+
     bool ba[] = {true, false, true, true, false};
     T vb(std::begin(ba), std::end(ba));
     H h;
     assert(h(vb) != 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::vector<bool, min_allocator<bool>> T;
     typedef std::hash<T> H;
-    static_assert((std::is_base_of<std::unary_function<T, std::size_t>,
-                                   H>::value), "");
+    static_assert((std::is_same<H::argument_type, T>::value), "" );
+    static_assert((std::is_same<H::result_type, std::size_t>::value), "" );
     bool ba[] = {true, false, true, true, false};
     T vb(std::begin(ba), std::end(ba));
     H h;
diff --git a/test/std/containers/sequences/vector/contiguous.pass.cpp b/test/std/containers/sequences/vector/contiguous.pass.cpp
index 32f380778335..70084246eae9 100644
--- a/test/std/containers/sequences/vector/contiguous.pass.cpp
+++ b/test/std/containers/sequences/vector/contiguous.pass.cpp
@@ -40,7 +40,7 @@ int main()
     test_contiguous(C(A(3)));
     test_contiguous(C(7, 9.0, A(5)));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef double T;
     typedef min_allocator<T> A;
diff --git a/test/std/containers/sequences/vector/iterators.pass.cpp b/test/std/containers/sequences/vector/iterators.pass.cpp
index 75a08287a863..8dc14977f282 100644
--- a/test/std/containers/sequences/vector/iterators.pass.cpp
+++ b/test/std/containers/sequences/vector/iterators.pass.cpp
@@ -77,7 +77,7 @@ int main()
         C::iterator i;
         C::const_iterator j;
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::vector<T, min_allocator<T>> C;
diff --git a/test/std/containers/sequences/vector/types.pass.cpp b/test/std/containers/sequences/vector/types.pass.cpp
index 0fbc7e38b1a2..2080ac09fc5a 100644
--- a/test/std/containers/sequences/vector/types.pass.cpp
+++ b/test/std/containers/sequences/vector/types.pass.cpp
@@ -45,6 +45,9 @@ test()
 {
     typedef std::vector<T, Allocator> C;
 
+//  TODO: These tests should use allocator_traits to get stuff, rather than
+//  blindly pulling typedefs out of the allocator. This is why we can't call
+//  test<int, min_allocator<int>>() below.
     static_assert((std::is_same<typename C::value_type, T>::value), "");
     static_assert((std::is_same<typename C::value_type, typename Allocator::value_type>::value), "");
     static_assert((std::is_same<typename C::allocator_type, Allocator>::value), "");
@@ -54,6 +57,14 @@ test()
     static_assert((std::is_same<typename C::const_reference, typename Allocator::const_reference>::value), "");
     static_assert((std::is_same<typename C::pointer, typename Allocator::pointer>::value), "");
     static_assert((std::is_same<typename C::const_pointer, typename Allocator::const_pointer>::value), "");
+
+    static_assert((std::is_signed<typename C::difference_type>::value), "");
+    static_assert((std::is_unsigned<typename C::size_type>::value), "");
+//     static_assert((std::is_same<typename C::difference_type,
+//         typename std::iterator_traits<typename C::iterator>::difference_type>::value), "");
+//     static_assert((std::is_same<typename C::difference_type,
+//         typename std::iterator_traits<typename C::const_iterator>::difference_type>::value), "");
+
     static_assert((std::is_same<
         typename std::iterator_traits<typename C::iterator>::iterator_category,
         std::random_access_iterator_tag>::value), "");
@@ -75,12 +86,23 @@ int main()
     test<Copyable, test_allocator<Copyable> >();
     static_assert((std::is_same<std::vector<char>::allocator_type,
                                 std::allocator<char> >::value), "");
-#if __cplusplus >= 201103L
-    static_assert((std::is_same<std::vector<int, min_allocator<int>>::value_type, int>::value), "");
-    static_assert((std::is_same<std::vector<int, min_allocator<int>>::allocator_type, min_allocator<int> >::value), "");
-    static_assert((std::is_same<std::vector<int, min_allocator<int>>::reference, int&>::value), "");
-    static_assert((std::is_same<std::vector<int, min_allocator<int>>::const_reference, const int&>::value), "");
-    static_assert((std::is_same<std::vector<int, min_allocator<int>>::pointer, min_pointer<int>>::value), "");
-    static_assert((std::is_same<std::vector<int, min_allocator<int>>::const_pointer, min_pointer<const int>>::value), "");
+#if TEST_STD_VER >= 11
+    {
+
+    typedef std::vector<int, min_allocator<int> > C;
+    static_assert((std::is_same<C::value_type, int>::value), "");
+    static_assert((std::is_same<C::allocator_type, min_allocator<int> >::value), "");
+    static_assert((std::is_same<C::reference, int&>::value), "");
+    static_assert((std::is_same<C::const_reference, const int&>::value), "");
+    static_assert((std::is_same<C::pointer, min_pointer<int>>::value), "");
+    static_assert((std::is_same<C::const_pointer, min_pointer<const int>>::value), "");
+
+    static_assert((std::is_signed<typename C::difference_type>::value), "");
+    static_assert((std::is_unsigned<typename C::size_type>::value), "");
+//     static_assert((std::is_same<typename C::difference_type,
+//         typename std::iterator_traits<typename C::iterator>::difference_type>::value), "");
+//     static_assert((std::is_same<typename C::difference_type,
+//         typename std::iterator_traits<typename C::const_iterator>::difference_type>::value), "");
+    }
 #endif
 }
diff --git a/test/std/containers/sequences/vector/vector.capacity/capacity.pass.cpp b/test/std/containers/sequences/vector/vector.capacity/capacity.pass.cpp
index 21082c839f56..a87b84061030 100644
--- a/test/std/containers/sequences/vector/vector.capacity/capacity.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.capacity/capacity.pass.cpp
@@ -22,27 +22,27 @@ int main()
     {
         std::vector<int> v;
         assert(v.capacity() == 0);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
     }
     {
         std::vector<int> v(100);
         assert(v.capacity() == 100);
         v.push_back(0);
         assert(v.capacity() > 101);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<int, min_allocator<int>> v;
         assert(v.capacity() == 0);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
     }
     {
         std::vector<int, min_allocator<int>> v(100);
         assert(v.capacity() == 100);
         v.push_back(0);
         assert(v.capacity() > 101);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
     }
 #endif
 }
diff --git a/test/std/containers/sequences/vector/vector.capacity/reserve.pass.cpp b/test/std/containers/sequences/vector/vector.capacity/reserve.pass.cpp
index 4df5702f2ad2..d04e43db508d 100644
--- a/test/std/containers/sequences/vector/vector.capacity/reserve.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.capacity/reserve.pass.cpp
@@ -23,7 +23,7 @@ int main()
         std::vector<int> v;
         v.reserve(10);
         assert(v.capacity() >= 10);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
     }
     {
         std::vector<int> v(100);
@@ -34,7 +34,7 @@ int main()
         v.reserve(150);
         assert(v.size() == 100);
         assert(v.capacity() == 150);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
     }
     {
         std::vector<int, stack_allocator<int, 250> > v(100);
@@ -45,14 +45,14 @@ int main()
         v.reserve(150);
         assert(v.size() == 100);
         assert(v.capacity() == 150);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<int, min_allocator<int>> v;
         v.reserve(10);
         assert(v.capacity() >= 10);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
     }
     {
         std::vector<int, min_allocator<int>> v(100);
@@ -63,7 +63,7 @@ int main()
         v.reserve(150);
         assert(v.size() == 100);
         assert(v.capacity() == 150);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
     }
 #endif
 }
diff --git a/test/std/containers/sequences/vector/vector.capacity/resize_size.pass.cpp b/test/std/containers/sequences/vector/vector.capacity/resize_size.pass.cpp
index c7988d62060a..ce74cf9b7c23 100644
--- a/test/std/containers/sequences/vector/vector.capacity/resize_size.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.capacity/resize_size.pass.cpp
@@ -26,22 +26,22 @@ int main()
         v.resize(50);
         assert(v.size() == 50);
         assert(v.capacity() == 100);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         v.resize(200);
         assert(v.size() == 200);
         assert(v.capacity() >= 200);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
     }
     {
         std::vector<MoveOnly, stack_allocator<MoveOnly, 300> > v(100);
         v.resize(50);
         assert(v.size() == 50);
         assert(v.capacity() == 100);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         v.resize(200);
         assert(v.size() == 200);
         assert(v.capacity() >= 200);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
     }
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
@@ -49,35 +49,35 @@ int main()
         v.resize(50);
         assert(v.size() == 50);
         assert(v.capacity() == 100);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         v.resize(200);
         assert(v.size() == 200);
         assert(v.capacity() >= 200);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
     }
     {
         std::vector<int, stack_allocator<int, 300> > v(100);
         v.resize(50);
         assert(v.size() == 50);
         assert(v.capacity() == 100);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         v.resize(200);
         assert(v.size() == 200);
         assert(v.capacity() >= 200);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
     }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<MoveOnly, min_allocator<MoveOnly>> v(100);
         v.resize(50);
         assert(v.size() == 50);
         assert(v.capacity() == 100);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         v.resize(200);
         assert(v.size() == 200);
         assert(v.capacity() >= 200);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
     }
 #endif
 }
diff --git a/test/std/containers/sequences/vector/vector.capacity/resize_size_value.pass.cpp b/test/std/containers/sequences/vector/vector.capacity/resize_size_value.pass.cpp
index de5126b03d10..3e7df312731f 100644
--- a/test/std/containers/sequences/vector/vector.capacity/resize_size_value.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.capacity/resize_size_value.pass.cpp
@@ -28,7 +28,7 @@ int main()
         v.resize(200, 1);
         assert(v.size() == 200);
         assert(v.capacity() >= 200);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         for (unsigned i = 0; i < 50; ++i)
             assert(v[i] == 0);
         for (unsigned i = 50; i < 200; ++i)
@@ -42,20 +42,20 @@ int main()
         v.resize(200, 1);
         assert(v.size() == 200);
         assert(v.capacity() >= 200);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<int, min_allocator<int>> v(100);
         v.resize(50, 1);
         assert(v.size() == 50);
         assert(v.capacity() == 100);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         assert((v == std::vector<int, min_allocator<int>>(50)));
         v.resize(200, 1);
         assert(v.size() == 200);
         assert(v.capacity() >= 200);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         for (unsigned i = 0; i < 50; ++i)
             assert(v[i] == 0);
         for (unsigned i = 50; i < 200; ++i)
@@ -66,11 +66,11 @@ int main()
         v.resize(50, 1);
         assert(v.size() == 50);
         assert(v.capacity() == 100);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         v.resize(200, 1);
         assert(v.size() == 200);
         assert(v.capacity() >= 200);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
     }
 #endif
 }
diff --git a/test/std/containers/sequences/vector/vector.capacity/shrink_to_fit.pass.cpp b/test/std/containers/sequences/vector/vector.capacity/shrink_to_fit.pass.cpp
index 49ab9cc71deb..10ce33f43bd2 100644
--- a/test/std/containers/sequences/vector/vector.capacity/shrink_to_fit.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.capacity/shrink_to_fit.pass.cpp
@@ -22,41 +22,41 @@ int main()
     {
         std::vector<int> v(100);
         v.push_back(1);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         v.shrink_to_fit();
         assert(v.capacity() == 101);
         assert(v.size() == 101);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
     }
     {
         std::vector<int, stack_allocator<int, 401> > v(100);
         v.push_back(1);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         v.shrink_to_fit();
         assert(v.capacity() == 101);
         assert(v.size() == 101);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
     }
 #ifndef _LIBCPP_NO_EXCEPTIONS
     {
         std::vector<int, stack_allocator<int, 400> > v(100);
         v.push_back(1);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         v.shrink_to_fit();
-        assert(v.capacity() == 200);
+        LIBCPP_ASSERT(v.capacity() == 200); // assumes libc++'s 2x growth factor
         assert(v.size() == 101);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
     }
 #endif
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<int, min_allocator<int>> v(100);
         v.push_back(1);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         v.shrink_to_fit();
         assert(v.capacity() == 101);
         assert(v.size() == 101);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
     }
 #endif
 }
diff --git a/test/std/containers/sequences/vector/vector.capacity/swap.pass.cpp b/test/std/containers/sequences/vector/vector.capacity/swap.pass.cpp
index f3d9289c36eb..59529a6dfd36 100644
--- a/test/std/containers/sequences/vector/vector.capacity/swap.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.capacity/swap.pass.cpp
@@ -22,29 +22,29 @@ int main()
     {
         std::vector<int> v1(100);
         std::vector<int> v2(200);
-        assert(is_contiguous_container_asan_correct(v1)); 
-        assert(is_contiguous_container_asan_correct(v2)); 
+        assert(is_contiguous_container_asan_correct(v1));
+        assert(is_contiguous_container_asan_correct(v2));
         v1.swap(v2);
         assert(v1.size() == 200);
         assert(v1.capacity() == 200);
-        assert(is_contiguous_container_asan_correct(v1)); 
+        assert(is_contiguous_container_asan_correct(v1));
         assert(v2.size() == 100);
         assert(v2.capacity() == 100);
-        assert(is_contiguous_container_asan_correct(v2)); 
+        assert(is_contiguous_container_asan_correct(v2));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<int, min_allocator<int>> v1(100);
         std::vector<int, min_allocator<int>> v2(200);
-        assert(is_contiguous_container_asan_correct(v1)); 
-        assert(is_contiguous_container_asan_correct(v2)); 
+        assert(is_contiguous_container_asan_correct(v1));
+        assert(is_contiguous_container_asan_correct(v2));
         v1.swap(v2);
         assert(v1.size() == 200);
         assert(v1.capacity() == 200);
-        assert(is_contiguous_container_asan_correct(v1)); 
+        assert(is_contiguous_container_asan_correct(v1));
         assert(v2.size() == 100);
         assert(v2.capacity() == 100);
-        assert(is_contiguous_container_asan_correct(v2)); 
+        assert(is_contiguous_container_asan_correct(v2));
     }
 #endif
 }
diff --git a/test/std/containers/sequences/vector/vector.cons/assign_copy.pass.cpp b/test/std/containers/sequences/vector/vector.cons/assign_copy.pass.cpp
index 6f02c3b7bc2b..d15d24dd969f 100644
--- a/test/std/containers/sequences/vector/vector.cons/assign_copy.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/assign_copy.pass.cpp
@@ -32,7 +32,7 @@ int main()
         assert(l2 == l);
         assert(l2.get_allocator() == other_allocator<int>(5));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<int, min_allocator<int> > l(3, 2, min_allocator<int>());
         std::vector<int, min_allocator<int> > l2(l, min_allocator<int>());
diff --git a/test/std/containers/sequences/vector/vector.cons/assign_initializer_list.pass.cpp b/test/std/containers/sequences/vector/vector.cons/assign_initializer_list.pass.cpp
index 3cb0b3b095f0..222fa9c78f92 100644
--- a/test/std/containers/sequences/vector/vector.cons/assign_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/assign_initializer_list.pass.cpp
@@ -23,7 +23,7 @@ void test ( Vec &v )
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     v.assign({3, 4, 5, 6});
     assert(v.size() == 4);
-    assert(is_contiguous_container_asan_correct(v)); 
+    assert(is_contiguous_container_asan_correct(v));
     assert(v[0] == 3);
     assert(v[1] == 4);
     assert(v[2] == 5);
@@ -42,7 +42,7 @@ int main()
     test(d2);
     }
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::vector<int, min_allocator<int>> V;
     V d1;
diff --git a/test/std/containers/sequences/vector/vector.cons/assign_move.pass.cpp b/test/std/containers/sequences/vector/vector.cons/assign_move.pass.cpp
index 8c8b0a04715b..acbee97bcd1c 100644
--- a/test/std/containers/sequences/vector/vector.cons/assign_move.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/assign_move.pass.cpp
@@ -29,72 +29,72 @@ int main()
             l.push_back(i);
             lo.push_back(i);
         }
-        assert(is_contiguous_container_asan_correct(l)); 
-        assert(is_contiguous_container_asan_correct(lo)); 
+        assert(is_contiguous_container_asan_correct(l));
+        assert(is_contiguous_container_asan_correct(lo));
         std::vector<MoveOnly, test_allocator<MoveOnly> > l2(test_allocator<MoveOnly>(5));
         l2 = std::move(l);
         assert(l2 == lo);
         assert(l.empty());
         assert(l2.get_allocator() == lo.get_allocator());
-        assert(is_contiguous_container_asan_correct(l2)); 
+        assert(is_contiguous_container_asan_correct(l2));
     }
     {
         std::vector<MoveOnly, test_allocator<MoveOnly> > l(test_allocator<MoveOnly>(5));
         std::vector<MoveOnly, test_allocator<MoveOnly> > lo(test_allocator<MoveOnly>(5));
-        assert(is_contiguous_container_asan_correct(l)); 
-        assert(is_contiguous_container_asan_correct(lo)); 
+        assert(is_contiguous_container_asan_correct(l));
+        assert(is_contiguous_container_asan_correct(lo));
         for (int i = 1; i <= 3; ++i)
         {
             l.push_back(i);
             lo.push_back(i);
         }
-        assert(is_contiguous_container_asan_correct(l)); 
-        assert(is_contiguous_container_asan_correct(lo)); 
+        assert(is_contiguous_container_asan_correct(l));
+        assert(is_contiguous_container_asan_correct(lo));
         std::vector<MoveOnly, test_allocator<MoveOnly> > l2(test_allocator<MoveOnly>(6));
         l2 = std::move(l);
         assert(l2 == lo);
         assert(!l.empty());
         assert(l2.get_allocator() == test_allocator<MoveOnly>(6));
-        assert(is_contiguous_container_asan_correct(l2)); 
+        assert(is_contiguous_container_asan_correct(l2));
     }
     {
         std::vector<MoveOnly, other_allocator<MoveOnly> > l(other_allocator<MoveOnly>(5));
         std::vector<MoveOnly, other_allocator<MoveOnly> > lo(other_allocator<MoveOnly>(5));
-        assert(is_contiguous_container_asan_correct(l)); 
-        assert(is_contiguous_container_asan_correct(lo)); 
+        assert(is_contiguous_container_asan_correct(l));
+        assert(is_contiguous_container_asan_correct(lo));
         for (int i = 1; i <= 3; ++i)
         {
             l.push_back(i);
             lo.push_back(i);
         }
-        assert(is_contiguous_container_asan_correct(l)); 
-        assert(is_contiguous_container_asan_correct(lo)); 
+        assert(is_contiguous_container_asan_correct(l));
+        assert(is_contiguous_container_asan_correct(lo));
         std::vector<MoveOnly, other_allocator<MoveOnly> > l2(other_allocator<MoveOnly>(6));
         l2 = std::move(l);
         assert(l2 == lo);
         assert(l.empty());
         assert(l2.get_allocator() == lo.get_allocator());
-        assert(is_contiguous_container_asan_correct(l2)); 
+        assert(is_contiguous_container_asan_correct(l2));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<MoveOnly, min_allocator<MoveOnly> > l(min_allocator<MoveOnly>{});
         std::vector<MoveOnly, min_allocator<MoveOnly> > lo(min_allocator<MoveOnly>{});
-        assert(is_contiguous_container_asan_correct(l)); 
-        assert(is_contiguous_container_asan_correct(lo)); 
+        assert(is_contiguous_container_asan_correct(l));
+        assert(is_contiguous_container_asan_correct(lo));
         for (int i = 1; i <= 3; ++i)
         {
             l.push_back(i);
             lo.push_back(i);
         }
-        assert(is_contiguous_container_asan_correct(l)); 
-        assert(is_contiguous_container_asan_correct(lo)); 
+        assert(is_contiguous_container_asan_correct(l));
+        assert(is_contiguous_container_asan_correct(lo));
         std::vector<MoveOnly, min_allocator<MoveOnly> > l2(min_allocator<MoveOnly>{});
         l2 = std::move(l);
         assert(l2 == lo);
         assert(l.empty());
         assert(l2.get_allocator() == lo.get_allocator());
-        assert(is_contiguous_container_asan_correct(l2)); 
+        assert(is_contiguous_container_asan_correct(l2));
     }
 #endif
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
diff --git a/test/std/containers/sequences/vector/vector.cons/assign_size_value.pass.cpp b/test/std/containers/sequences/vector/vector.cons/assign_size_value.pass.cpp
index e1b30bf11304..8e5d2766c775 100644
--- a/test/std/containers/sequences/vector/vector.cons/assign_size_value.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/assign_size_value.pass.cpp
@@ -26,7 +26,7 @@ void test ( Vec &v )
 {
     v.assign(5, 6);
     assert(v.size() == 5);
-    assert(is_contiguous_container_asan_correct(v)); 
+    assert(is_contiguous_container_asan_correct(v));
     assert(std::all_of(v.begin(), v.end(), is6));
 }
 
@@ -41,7 +41,7 @@ int main()
     test(d2);
     }
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::vector<int, min_allocator<int>> V;
     V d1;
diff --git a/test/std/containers/sequences/vector/vector.cons/construct_default.pass.cpp b/test/std/containers/sequences/vector/vector.cons/construct_default.pass.cpp
index 5e87c07ef70a..e0542e751f44 100644
--- a/test/std/containers/sequences/vector/vector.cons/construct_default.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/construct_default.pass.cpp
@@ -32,16 +32,16 @@ test0()
 	static_assert((noexcept(C()) == noexcept(typename C::allocator_type())), "" );
 #endif
     C c;
-    assert(c.__invariants());
+    LIBCPP_ASSERT(c.__invariants());
     assert(c.empty());
     assert(c.get_allocator() == typename C::allocator_type());
-    assert(is_contiguous_container_asan_correct(c)); 
+    LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
 #if TEST_STD_VER >= 11
     C c1 = {};
-    assert(c1.__invariants());
+    LIBCPP_ASSERT(c1.__invariants());
     assert(c1.empty());
     assert(c1.get_allocator() == typename C::allocator_type());
-    assert(is_contiguous_container_asan_correct(c1)); 
+    LIBCPP_ASSERT(is_contiguous_container_asan_correct(c1));
 #endif
 }
 
@@ -55,10 +55,10 @@ test1(const typename C::allocator_type& a)
 	static_assert((noexcept(C(typename C::allocator_type())) == std::is_nothrow_copy_constructible<typename C::allocator_type>::value), "" );
 #endif
     C c(a);
-    assert(c.__invariants());
+    LIBCPP_ASSERT(c.__invariants());
     assert(c.empty());
     assert(c.get_allocator() == a);
-    assert(is_contiguous_container_asan_correct(c)); 
+    LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
 }
 
 int main()
diff --git a/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp b/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
index 36e231acce12..5542e91059d6 100644
--- a/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
@@ -14,6 +14,7 @@
 #include <vector>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../stack_allocator.h"
 #include "min_allocator.h"
@@ -24,9 +25,9 @@ void
 test(Iterator first, Iterator last)
 {
     C c(first, last);
-    assert(c.__invariants());
+    LIBCPP_ASSERT(c.__invariants());
     assert(c.size() == std::distance(first, last));
-    assert(is_contiguous_container_asan_correct(c)); 
+    LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
     for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i, ++first)
         assert(*i == *first);
 }
@@ -46,7 +47,7 @@ int main()
     test<std::vector<int, stack_allocator<int, 18> > >(bidirectional_iterator<const int*>(a), bidirectional_iterator<const int*>(an));
     test<std::vector<int, stack_allocator<int, 18> > >(random_access_iterator<const int*>(a), random_access_iterator<const int*>(an));
     test<std::vector<int, stack_allocator<int, 18> > >(a, an);
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test<std::vector<int, min_allocator<int>> >(input_iterator<const int*>(a), input_iterator<const int*>(an));
     test<std::vector<int, min_allocator<int>> >(forward_iterator<const int*>(a), forward_iterator<const int*>(an));
     test<std::vector<int, min_allocator<int>> >(bidirectional_iterator<const int*>(a), bidirectional_iterator<const int*>(an));
diff --git a/test/std/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp b/test/std/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp
index 7fa748a90d71..f40088ea3e86 100644
--- a/test/std/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp
@@ -15,6 +15,7 @@
 #include <vector>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../stack_allocator.h"
 #include "min_allocator.h"
@@ -25,19 +26,19 @@ void
 test(Iterator first, Iterator last, const A& a)
 {
     C c(first, last, a);
-    assert(c.__invariants());
+    LIBCPP_ASSERT(c.__invariants());
     assert(c.size() == std::distance(first, last));
-    assert(is_contiguous_container_asan_correct(c)); 
+    LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
     for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i, ++first)
         assert(*i == *first);
 }
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
 
 template <class T>
 struct implicit_conv_allocator : min_allocator<T>
 {
-    implicit_conv_allocator(void* p) {}
+    implicit_conv_allocator(void*) {}
     implicit_conv_allocator(const implicit_conv_allocator&) = default;
 };
 
@@ -55,7 +56,7 @@ int main()
     test<std::vector<int> >(random_access_iterator<const int*>(a), random_access_iterator<const int*>(an), alloc);
     test<std::vector<int> >(a, an, alloc);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 1, 0};
     int* an = a + sizeof(a)/sizeof(a[0]);
diff --git a/test/std/containers/sequences/vector/vector.cons/construct_size.pass.cpp b/test/std/containers/sequences/vector/vector.cons/construct_size.pass.cpp
index e03389593f16..46e5ecdc9a56 100644
--- a/test/std/containers/sequences/vector/vector.cons/construct_size.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/construct_size.pass.cpp
@@ -14,6 +14,7 @@
 #include <vector>
 #include <cassert>
 
+#include "test_macros.h"
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 #include "test_allocator.h"
@@ -23,16 +24,14 @@ template <class C>
 void
 test2(typename C::size_type n, typename C::allocator_type const& a = typename C::allocator_type ())
 {
-#if _LIBCPP_STD_VER > 11
+#if TEST_STD_VER >= 14
     C c(n, a);
-    assert(c.__invariants());
+    LIBCPP_ASSERT(c.__invariants());
     assert(c.size() == n);
     assert(c.get_allocator() == a);
-    assert(is_contiguous_container_asan_correct(c)); 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
     for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i)
         assert(*i == typename C::value_type());
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 #endif
 }
 
@@ -41,14 +40,14 @@ void
 test1(typename C::size_type n)
 {
     C c(n);
-    assert(c.__invariants());
+    LIBCPP_ASSERT(c.__invariants());
     assert(c.size() == n);
     assert(c.get_allocator() == typename C::allocator_type());
-    assert(is_contiguous_container_asan_correct(c)); 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
+#if TEST_STD_VER >= 11
     for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i)
         assert(*i == typename C::value_type());
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 }
 
 template <class C>
@@ -64,7 +63,7 @@ int main()
     test<std::vector<int> >(50);
     test<std::vector<DefaultOnly> >(500);
     assert(DefaultOnly::count == 0);
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test<std::vector<int, min_allocator<int>> >(50);
     test<std::vector<DefaultOnly, min_allocator<DefaultOnly>> >(500);
     test2<std::vector<DefaultOnly, test_allocator<DefaultOnly>> >( 100, test_allocator<DefaultOnly>(23));
diff --git a/test/std/containers/sequences/vector/vector.cons/construct_size_value.pass.cpp b/test/std/containers/sequences/vector/vector.cons/construct_size_value.pass.cpp
index 5b6c49857044..d3774d1a6595 100644
--- a/test/std/containers/sequences/vector/vector.cons/construct_size_value.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/construct_size_value.pass.cpp
@@ -14,6 +14,7 @@
 #include <vector>
 #include <cassert>
 
+#include "test_macros.h"
 #include "../../../stack_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
@@ -23,9 +24,9 @@ void
 test(typename C::size_type n, const typename C::value_type& x)
 {
     C c(n, x);
-    assert(c.__invariants());
+    LIBCPP_ASSERT(c.__invariants());
     assert(c.size() == n);
-    assert(is_contiguous_container_asan_correct(c)); 
+    LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
     for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i)
         assert(*i == x);
 }
@@ -34,7 +35,7 @@ int main()
 {
     test<std::vector<int> >(50, 3);
     test<std::vector<int, stack_allocator<int, 50> > >(50, 5);
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test<std::vector<int, min_allocator<int>> >(50, 3);
 #endif
 }
diff --git a/test/std/containers/sequences/vector/vector.cons/construct_size_value_alloc.pass.cpp b/test/std/containers/sequences/vector/vector.cons/construct_size_value_alloc.pass.cpp
index c62b84104aba..4713aa157062 100644
--- a/test/std/containers/sequences/vector/vector.cons/construct_size_value_alloc.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/construct_size_value_alloc.pass.cpp
@@ -13,6 +13,8 @@
 
 #include <vector>
 #include <cassert>
+
+#include "test_macros.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
@@ -22,10 +24,10 @@ test(typename C::size_type n, const typename C::value_type& x,
      const typename C::allocator_type& a)
 {
     C c(n, x, a);
-    assert(c.__invariants());
+    LIBCPP_ASSERT(c.__invariants());
     assert(a == c.get_allocator());
     assert(c.size() == n);
-    assert(is_contiguous_container_asan_correct(c)); 
+    LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
     for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i)
         assert(*i == x);
 }
@@ -33,7 +35,7 @@ test(typename C::size_type n, const typename C::value_type& x,
 int main()
 {
     test<std::vector<int> >(50, 3, std::allocator<int>());
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test<std::vector<int, min_allocator<int>> >(50, 3, min_allocator<int>());
 #endif
 }
diff --git a/test/std/containers/sequences/vector/vector.cons/copy.pass.cpp b/test/std/containers/sequences/vector/vector.cons/copy.pass.cpp
index 677963deeb84..105217bbf15c 100644
--- a/test/std/containers/sequences/vector/vector.cons/copy.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/copy.pass.cpp
@@ -13,6 +13,8 @@
 
 #include <vector>
 #include <cassert>
+
+#include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
@@ -23,10 +25,10 @@ test(const C& x)
 {
     unsigned s = x.size();
     C c(x);
-    assert(c.__invariants());
+    LIBCPP_ASSERT(c.__invariants());
     assert(c.size() == s);
     assert(c == x);
-    assert(is_contiguous_container_asan_correct(c)); 
+    LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
 }
 
 int main()
@@ -39,26 +41,24 @@ int main()
     {
         std::vector<int, test_allocator<int> > v(3, 2, test_allocator<int>(5));
         std::vector<int, test_allocator<int> > v2 = v;
-        assert(is_contiguous_container_asan_correct(v)); 
-        assert(is_contiguous_container_asan_correct(v2)); 
+        assert(is_contiguous_container_asan_correct(v));
+        assert(is_contiguous_container_asan_correct(v2));
         assert(v2 == v);
         assert(v2.get_allocator() == v.get_allocator());
-        assert(is_contiguous_container_asan_correct(v)); 
-        assert(is_contiguous_container_asan_correct(v2)); 
+        assert(is_contiguous_container_asan_correct(v));
+        assert(is_contiguous_container_asan_correct(v2));
     }
-#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#if TEST_STD_VER >= 11
     {
         std::vector<int, other_allocator<int> > v(3, 2, other_allocator<int>(5));
         std::vector<int, other_allocator<int> > v2 = v;
-        assert(is_contiguous_container_asan_correct(v)); 
-        assert(is_contiguous_container_asan_correct(v2)); 
+        assert(is_contiguous_container_asan_correct(v));
+        assert(is_contiguous_container_asan_correct(v2));
         assert(v2 == v);
         assert(v2.get_allocator() == other_allocator<int>(-2));
-        assert(is_contiguous_container_asan_correct(v)); 
-        assert(is_contiguous_container_asan_correct(v2)); 
+        assert(is_contiguous_container_asan_correct(v));
+        assert(is_contiguous_container_asan_correct(v2));
     }
-#endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
-#if __cplusplus >= 201103L
     {
         int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 1, 0};
         int* an = a + sizeof(a)/sizeof(a[0]);
@@ -67,12 +67,12 @@ int main()
     {
         std::vector<int, min_allocator<int> > v(3, 2, min_allocator<int>());
         std::vector<int, min_allocator<int> > v2 = v;
-        assert(is_contiguous_container_asan_correct(v)); 
-        assert(is_contiguous_container_asan_correct(v2)); 
+        assert(is_contiguous_container_asan_correct(v));
+        assert(is_contiguous_container_asan_correct(v2));
         assert(v2 == v);
         assert(v2.get_allocator() == v.get_allocator());
-        assert(is_contiguous_container_asan_correct(v)); 
-        assert(is_contiguous_container_asan_correct(v2)); 
+        assert(is_contiguous_container_asan_correct(v));
+        assert(is_contiguous_container_asan_correct(v2));
     }
 #endif
 }
diff --git a/test/std/containers/sequences/vector/vector.cons/copy_alloc.pass.cpp b/test/std/containers/sequences/vector/vector.cons/copy_alloc.pass.cpp
index 128328c2a7d2..47259c747332 100644
--- a/test/std/containers/sequences/vector/vector.cons/copy_alloc.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/copy_alloc.pass.cpp
@@ -13,6 +13,8 @@
 
 #include <vector>
 #include <cassert>
+
+#include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
@@ -23,10 +25,10 @@ test(const C& x, const typename C::allocator_type& a)
 {
     unsigned s = x.size();
     C c(x, a);
-    assert(c.__invariants());
+    LIBCPP_ASSERT(c.__invariants());
     assert(c.size() == s);
     assert(c == x);
-    assert(is_contiguous_container_asan_correct(c)); 
+    LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
 }
 
 int main()
@@ -48,7 +50,7 @@ int main()
         assert(l2 == l);
         assert(l2.get_allocator() == other_allocator<int>(3));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 1, 0};
         int* an = a + sizeof(a)/sizeof(a[0]);
diff --git a/test/std/containers/sequences/vector/vector.cons/default_noexcept.pass.cpp b/test/std/containers/sequences/vector/vector.cons/default_noexcept.pass.cpp
index 60f7b72c9477..b244f75f21d4 100644
--- a/test/std/containers/sequences/vector/vector.cons/default_noexcept.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/default_noexcept.pass.cpp
@@ -14,6 +14,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <vector>
 #include <cassert>
 
@@ -30,7 +32,6 @@ struct some_alloc
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::vector<MoveOnly> C;
         static_assert(std::is_nothrow_default_constructible<C>::value, "");
@@ -47,5 +48,4 @@ int main()
         typedef std::vector<MoveOnly, some_alloc<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/sequences/vector/vector.cons/dtor_noexcept.pass.cpp b/test/std/containers/sequences/vector/vector.cons/dtor_noexcept.pass.cpp
index 0e2cae9ee935..bd538120442d 100644
--- a/test/std/containers/sequences/vector/vector.cons/dtor_noexcept.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/dtor_noexcept.pass.cpp
@@ -11,14 +11,14 @@
 
 // ~vector() // implied noexcept;
 
+// UNSUPPORTED: c++98, c++03
+
 #include <vector>
 #include <cassert>
 
 #include "MoveOnly.h"
 #include "test_allocator.h"
 
-#if __has_feature(cxx_noexcept)
-
 template <class T>
 struct some_alloc
 {
@@ -27,11 +27,8 @@ struct some_alloc
     ~some_alloc() noexcept(false);
 };
 
-#endif
-
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::vector<MoveOnly> C;
         static_assert(std::is_nothrow_destructible<C>::value, "");
@@ -48,5 +45,4 @@ int main()
         typedef std::vector<MoveOnly, some_alloc<MoveOnly>> C;
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/sequences/vector/vector.cons/initializer_list.pass.cpp b/test/std/containers/sequences/vector/vector.cons/initializer_list.pass.cpp
index 7eb834ff3877..408bcc3b1499 100644
--- a/test/std/containers/sequences/vector/vector.cons/initializer_list.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/initializer_list.pass.cpp
@@ -22,17 +22,17 @@ int main()
     {
     std::vector<int> d = {3, 4, 5, 6};
     assert(d.size() == 4);
-    assert(is_contiguous_container_asan_correct(d)); 
+    assert(is_contiguous_container_asan_correct(d));
     assert(d[0] == 3);
     assert(d[1] == 4);
     assert(d[2] == 5);
     assert(d[3] == 6);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     std::vector<int, min_allocator<int>> d = {3, 4, 5, 6};
     assert(d.size() == 4);
-    assert(is_contiguous_container_asan_correct(d)); 
+    assert(is_contiguous_container_asan_correct(d));
     assert(d[0] == 3);
     assert(d[1] == 4);
     assert(d[2] == 5);
diff --git a/test/std/containers/sequences/vector/vector.cons/initializer_list_alloc.pass.cpp b/test/std/containers/sequences/vector/vector.cons/initializer_list_alloc.pass.cpp
index 5d7ae884e382..f4c3b5c1e8e0 100644
--- a/test/std/containers/sequences/vector/vector.cons/initializer_list_alloc.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/initializer_list_alloc.pass.cpp
@@ -25,18 +25,18 @@ int main()
     std::vector<int, test_allocator<int>> d({3, 4, 5, 6}, test_allocator<int>(3));
     assert(d.get_allocator() == test_allocator<int>(3));
     assert(d.size() == 4);
-    assert(is_contiguous_container_asan_correct(d)); 
+    assert(is_contiguous_container_asan_correct(d));
     assert(d[0] == 3);
     assert(d[1] == 4);
     assert(d[2] == 5);
     assert(d[3] == 6);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     std::vector<int, min_allocator<int>> d({3, 4, 5, 6}, min_allocator<int>());
     assert(d.get_allocator() == min_allocator<int>());
     assert(d.size() == 4);
-    assert(is_contiguous_container_asan_correct(d)); 
+    assert(is_contiguous_container_asan_correct(d));
     assert(d[0] == 3);
     assert(d[1] == 4);
     assert(d[2] == 5);
diff --git a/test/std/containers/sequences/vector/vector.cons/move.pass.cpp b/test/std/containers/sequences/vector/vector.cons/move.pass.cpp
index fb419d825d2b..d51b364f3ba0 100644
--- a/test/std/containers/sequences/vector/vector.cons/move.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/move.pass.cpp
@@ -24,79 +24,79 @@ int main()
     {
         std::vector<MoveOnly, test_allocator<MoveOnly> > l(test_allocator<MoveOnly>(5));
         std::vector<MoveOnly, test_allocator<MoveOnly> > lo(test_allocator<MoveOnly>(5));
-        assert(is_contiguous_container_asan_correct(l)); 
-        assert(is_contiguous_container_asan_correct(lo)); 
+        assert(is_contiguous_container_asan_correct(l));
+        assert(is_contiguous_container_asan_correct(lo));
         for (int i = 1; i <= 3; ++i)
         {
             l.push_back(i);
             lo.push_back(i);
         }
-        assert(is_contiguous_container_asan_correct(l)); 
-        assert(is_contiguous_container_asan_correct(lo)); 
+        assert(is_contiguous_container_asan_correct(l));
+        assert(is_contiguous_container_asan_correct(lo));
         std::vector<MoveOnly, test_allocator<MoveOnly> > l2 = std::move(l);
         assert(l2 == lo);
         assert(l.empty());
         assert(l2.get_allocator() == lo.get_allocator());
-        assert(is_contiguous_container_asan_correct(l2)); 
+        assert(is_contiguous_container_asan_correct(l2));
     }
     {
         std::vector<MoveOnly, other_allocator<MoveOnly> > l(other_allocator<MoveOnly>(5));
         std::vector<MoveOnly, other_allocator<MoveOnly> > lo(other_allocator<MoveOnly>(5));
-        assert(is_contiguous_container_asan_correct(l)); 
-        assert(is_contiguous_container_asan_correct(lo)); 
+        assert(is_contiguous_container_asan_correct(l));
+        assert(is_contiguous_container_asan_correct(lo));
         for (int i = 1; i <= 3; ++i)
         {
             l.push_back(i);
             lo.push_back(i);
         }
-        assert(is_contiguous_container_asan_correct(l)); 
-        assert(is_contiguous_container_asan_correct(lo)); 
+        assert(is_contiguous_container_asan_correct(l));
+        assert(is_contiguous_container_asan_correct(lo));
         std::vector<MoveOnly, other_allocator<MoveOnly> > l2 = std::move(l);
         assert(l2 == lo);
         assert(l.empty());
         assert(l2.get_allocator() == lo.get_allocator());
-        assert(is_contiguous_container_asan_correct(l2)); 
+        assert(is_contiguous_container_asan_correct(l2));
     }
     {
         int a1[] = {1, 3, 7, 9, 10};
         std::vector<int> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
-        assert(is_contiguous_container_asan_correct(c1)); 
+        assert(is_contiguous_container_asan_correct(c1));
         std::vector<int>::const_iterator i = c1.begin();
         std::vector<int> c2 = std::move(c1);
-        assert(is_contiguous_container_asan_correct(c2)); 
+        assert(is_contiguous_container_asan_correct(c2));
         std::vector<int>::iterator j = c2.erase(i);
         assert(*j == 3);
-        assert(is_contiguous_container_asan_correct(c2)); 
+        assert(is_contiguous_container_asan_correct(c2));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<MoveOnly, min_allocator<MoveOnly> > l(min_allocator<MoveOnly>{});
         std::vector<MoveOnly, min_allocator<MoveOnly> > lo(min_allocator<MoveOnly>{});
-        assert(is_contiguous_container_asan_correct(l)); 
-        assert(is_contiguous_container_asan_correct(lo)); 
+        assert(is_contiguous_container_asan_correct(l));
+        assert(is_contiguous_container_asan_correct(lo));
         for (int i = 1; i <= 3; ++i)
         {
             l.push_back(i);
             lo.push_back(i);
         }
-        assert(is_contiguous_container_asan_correct(l)); 
-        assert(is_contiguous_container_asan_correct(lo)); 
+        assert(is_contiguous_container_asan_correct(l));
+        assert(is_contiguous_container_asan_correct(lo));
         std::vector<MoveOnly, min_allocator<MoveOnly> > l2 = std::move(l);
         assert(l2 == lo);
         assert(l.empty());
         assert(l2.get_allocator() == lo.get_allocator());
-        assert(is_contiguous_container_asan_correct(l2)); 
+        assert(is_contiguous_container_asan_correct(l2));
     }
     {
         int a1[] = {1, 3, 7, 9, 10};
         std::vector<int, min_allocator<int>> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
-        assert(is_contiguous_container_asan_correct(c1)); 
+        assert(is_contiguous_container_asan_correct(c1));
         std::vector<int, min_allocator<int>>::const_iterator i = c1.begin();
         std::vector<int, min_allocator<int>> c2 = std::move(c1);
-        assert(is_contiguous_container_asan_correct(c2)); 
+        assert(is_contiguous_container_asan_correct(c2));
         std::vector<int, min_allocator<int>>::iterator j = c2.erase(i);
         assert(*j == 3);
-        assert(is_contiguous_container_asan_correct(c2)); 
+        assert(is_contiguous_container_asan_correct(c2));
     }
 #endif
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
diff --git a/test/std/containers/sequences/vector/vector.cons/move_alloc.pass.cpp b/test/std/containers/sequences/vector/vector.cons/move_alloc.pass.cpp
index aef96917cb32..fcdd35ae1157 100644
--- a/test/std/containers/sequences/vector/vector.cons/move_alloc.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/move_alloc.pass.cpp
@@ -24,75 +24,75 @@ int main()
     {
         std::vector<MoveOnly, test_allocator<MoveOnly> > l(test_allocator<MoveOnly>(5));
         std::vector<MoveOnly, test_allocator<MoveOnly> > lo(test_allocator<MoveOnly>(5));
-        assert(is_contiguous_container_asan_correct(l)); 
-        assert(is_contiguous_container_asan_correct(lo)); 
+        assert(is_contiguous_container_asan_correct(l));
+        assert(is_contiguous_container_asan_correct(lo));
         for (int i = 1; i <= 3; ++i)
         {
             l.push_back(i);
             lo.push_back(i);
         }
-        assert(is_contiguous_container_asan_correct(l)); 
-        assert(is_contiguous_container_asan_correct(lo)); 
+        assert(is_contiguous_container_asan_correct(l));
+        assert(is_contiguous_container_asan_correct(lo));
         std::vector<MoveOnly, test_allocator<MoveOnly> > l2(std::move(l), test_allocator<MoveOnly>(6));
         assert(l2 == lo);
         assert(!l.empty());
         assert(l2.get_allocator() == test_allocator<MoveOnly>(6));
-        assert(is_contiguous_container_asan_correct(l2)); 
+        assert(is_contiguous_container_asan_correct(l2));
     }
     {
         std::vector<MoveOnly, test_allocator<MoveOnly> > l(test_allocator<MoveOnly>(5));
         std::vector<MoveOnly, test_allocator<MoveOnly> > lo(test_allocator<MoveOnly>(5));
-        assert(is_contiguous_container_asan_correct(l)); 
-        assert(is_contiguous_container_asan_correct(lo)); 
+        assert(is_contiguous_container_asan_correct(l));
+        assert(is_contiguous_container_asan_correct(lo));
         for (int i = 1; i <= 3; ++i)
         {
             l.push_back(i);
             lo.push_back(i);
         }
-        assert(is_contiguous_container_asan_correct(l)); 
-        assert(is_contiguous_container_asan_correct(lo)); 
+        assert(is_contiguous_container_asan_correct(l));
+        assert(is_contiguous_container_asan_correct(lo));
         std::vector<MoveOnly, test_allocator<MoveOnly> > l2(std::move(l), test_allocator<MoveOnly>(5));
         assert(l2 == lo);
         assert(l.empty());
         assert(l2.get_allocator() == test_allocator<MoveOnly>(5));
-        assert(is_contiguous_container_asan_correct(l2)); 
+        assert(is_contiguous_container_asan_correct(l2));
     }
     {
         std::vector<MoveOnly, other_allocator<MoveOnly> > l(other_allocator<MoveOnly>(5));
         std::vector<MoveOnly, other_allocator<MoveOnly> > lo(other_allocator<MoveOnly>(5));
-        assert(is_contiguous_container_asan_correct(l)); 
-        assert(is_contiguous_container_asan_correct(lo)); 
+        assert(is_contiguous_container_asan_correct(l));
+        assert(is_contiguous_container_asan_correct(lo));
         for (int i = 1; i <= 3; ++i)
         {
             l.push_back(i);
             lo.push_back(i);
         }
-        assert(is_contiguous_container_asan_correct(l)); 
-        assert(is_contiguous_container_asan_correct(lo)); 
+        assert(is_contiguous_container_asan_correct(l));
+        assert(is_contiguous_container_asan_correct(lo));
         std::vector<MoveOnly, other_allocator<MoveOnly> > l2(std::move(l), other_allocator<MoveOnly>(4));
         assert(l2 == lo);
         assert(!l.empty());
         assert(l2.get_allocator() == other_allocator<MoveOnly>(4));
-        assert(is_contiguous_container_asan_correct(l2)); 
+        assert(is_contiguous_container_asan_correct(l2));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<MoveOnly, min_allocator<MoveOnly> > l(min_allocator<MoveOnly>{});
         std::vector<MoveOnly, min_allocator<MoveOnly> > lo(min_allocator<MoveOnly>{});
-        assert(is_contiguous_container_asan_correct(l)); 
-        assert(is_contiguous_container_asan_correct(lo)); 
+        assert(is_contiguous_container_asan_correct(l));
+        assert(is_contiguous_container_asan_correct(lo));
         for (int i = 1; i <= 3; ++i)
         {
             l.push_back(i);
             lo.push_back(i);
         }
-        assert(is_contiguous_container_asan_correct(l)); 
-        assert(is_contiguous_container_asan_correct(lo)); 
+        assert(is_contiguous_container_asan_correct(l));
+        assert(is_contiguous_container_asan_correct(lo));
         std::vector<MoveOnly, min_allocator<MoveOnly> > l2(std::move(l), min_allocator<MoveOnly>());
         assert(l2 == lo);
         assert(l.empty());
         assert(l2.get_allocator() == min_allocator<MoveOnly>());
-        assert(is_contiguous_container_asan_correct(l2)); 
+        assert(is_contiguous_container_asan_correct(l2));
     }
 #endif
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
diff --git a/test/std/containers/sequences/vector/vector.cons/move_assign_noexcept.pass.cpp b/test/std/containers/sequences/vector/vector.cons/move_assign_noexcept.pass.cpp
index c09224497966..14ca7155b5a1 100644
--- a/test/std/containers/sequences/vector/vector.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/move_assign_noexcept.pass.cpp
@@ -16,6 +16,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <vector>
 #include <cassert>
 
@@ -33,7 +35,7 @@ template <class T>
 struct some_alloc2
 {
     typedef T value_type;
-    
+
     some_alloc2() {}
     some_alloc2(const some_alloc2&);
     void deallocate(void*, unsigned) {}
@@ -46,7 +48,7 @@ template <class T>
 struct some_alloc3
 {
     typedef T value_type;
-    
+
     some_alloc3() {}
     some_alloc3(const some_alloc3&);
     void deallocate(void*, unsigned) {}
@@ -58,7 +60,6 @@ struct some_alloc3
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::vector<MoveOnly> C;
         static_assert(std::is_nothrow_move_assignable<C>::value, "");
@@ -91,6 +92,4 @@ int main()
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
 #endif
-
-#endif
 }
diff --git a/test/std/containers/sequences/vector/vector.cons/move_noexcept.pass.cpp b/test/std/containers/sequences/vector/vector.cons/move_noexcept.pass.cpp
index b7bbfaa421c4..a1e3a632f1f2 100644
--- a/test/std/containers/sequences/vector/vector.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/move_noexcept.pass.cpp
@@ -14,6 +14,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <vector>
 #include <cassert>
 
@@ -29,7 +31,6 @@ struct some_alloc
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::vector<MoveOnly> C;
         static_assert(std::is_nothrow_move_constructible<C>::value, "");
@@ -51,5 +52,4 @@ int main()
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
 #endif
     }
-#endif
 }
diff --git a/test/std/containers/sequences/vector/vector.cons/op_equal_initializer_list.pass.cpp b/test/std/containers/sequences/vector/vector.cons/op_equal_initializer_list.pass.cpp
index 592b71462767..4e5a20413683 100644
--- a/test/std/containers/sequences/vector/vector.cons/op_equal_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/op_equal_initializer_list.pass.cpp
@@ -24,18 +24,18 @@ int main()
     std::vector<int> d;
     d = {3, 4, 5, 6};
     assert(d.size() == 4);
-    assert(is_contiguous_container_asan_correct(d)); 
+    assert(is_contiguous_container_asan_correct(d));
     assert(d[0] == 3);
     assert(d[1] == 4);
     assert(d[2] == 5);
     assert(d[3] == 6);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     std::vector<int, min_allocator<int>> d;
     d = {3, 4, 5, 6};
     assert(d.size() == 4);
-    assert(is_contiguous_container_asan_correct(d)); 
+    assert(is_contiguous_container_asan_correct(d));
     assert(d[0] == 3);
     assert(d[1] == 4);
     assert(d[2] == 5);
diff --git a/test/std/containers/sequences/vector/vector.data/data.pass.cpp b/test/std/containers/sequences/vector/vector.data/data.pass.cpp
index aed56bc09310..f6c0575d958c 100644
--- a/test/std/containers/sequences/vector/vector.data/data.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.data/data.pass.cpp
@@ -17,28 +17,47 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
+struct Nasty {
+	Nasty() : i_(0) {}
+	Nasty(int i) : i_(i) {}
+	~Nasty() {}
+	
+	Nasty * operator&() const { assert(false); return nullptr; }
+	int i_;
+	};
+
 int main()
 {
     {
         std::vector<int> v;
         assert(v.data() == 0);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
     }
     {
         std::vector<int> v(100);
-        assert(v.data() == &v.front());
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(v.data() == std::addressof(v.front()));
+        assert(is_contiguous_container_asan_correct(v));
+    }
+    {
+        std::vector<Nasty> v(100);
+        assert(v.data() == std::addressof(v.front()));
+        assert(is_contiguous_container_asan_correct(v));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<int, min_allocator<int>> v;
         assert(v.data() == 0);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
     }
     {
         std::vector<int, min_allocator<int>> v(100);
-        assert(v.data() == &v.front());
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(v.data() == std::addressof(v.front()));
+        assert(is_contiguous_container_asan_correct(v));
+    }
+    {
+        std::vector<Nasty, min_allocator<Nasty>> v(100);
+        assert(v.data() == std::addressof(v.front()));
+        assert(is_contiguous_container_asan_correct(v));
     }
 #endif
 }
diff --git a/test/std/containers/sequences/vector/vector.data/data_const.pass.cpp b/test/std/containers/sequences/vector/vector.data/data_const.pass.cpp
index cb6062694e40..c97ad29708b8 100644
--- a/test/std/containers/sequences/vector/vector.data/data_const.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.data/data_const.pass.cpp
@@ -17,28 +17,47 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
+struct Nasty {
+	Nasty() : i_(0) {}
+	Nasty(int i) : i_(i) {}
+	~Nasty() {}
+	
+	Nasty * operator&() const { assert(false); return nullptr; }
+	int i_;
+	};
+
 int main()
 {
     {
         const std::vector<int> v;
         assert(v.data() == 0);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
     }
     {
         const std::vector<int> v(100);
-        assert(v.data() == &v.front());
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(v.data() == std::addressof(v.front()));
+        assert(is_contiguous_container_asan_correct(v));
+    }
+    {
+        std::vector<Nasty> v(100);
+        assert(v.data() == std::addressof(v.front()));
+        assert(is_contiguous_container_asan_correct(v));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         const std::vector<int, min_allocator<int>> v;
         assert(v.data() == 0);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
     }
     {
         const std::vector<int, min_allocator<int>> v(100);
         assert(v.data() == &v.front());
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
+    }
+    {
+        std::vector<Nasty, min_allocator<Nasty>> v(100);
+        assert(v.data() == std::addressof(v.front()));
+        assert(is_contiguous_container_asan_correct(v));
     }
 #endif
 }
diff --git a/test/std/containers/sequences/vector/vector.modifiers/emplace.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/emplace.pass.cpp
index 8af6bdacd0a8..8bcc23979668 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/emplace.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/emplace.pass.cpp
@@ -67,7 +67,7 @@ int main()
         assert(c.size() == 1);
         assert(c.front().geti() == 2);
         assert(c.front().getd() == 3.5);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         i = c.emplace(c.cend(), 3, 4.5);
         assert(i == c.end()-1);
         assert(c.size() == 2);
@@ -75,7 +75,7 @@ int main()
         assert(c.front().getd() == 3.5);
         assert(c.back().geti() == 3);
         assert(c.back().getd() == 4.5);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         i = c.emplace(c.cbegin()+1, 4, 6.5);
         assert(i == c.begin()+1);
         assert(c.size() == 3);
@@ -85,7 +85,7 @@ int main()
         assert(c[1].getd() == 6.5);
         assert(c.back().geti() == 3);
         assert(c.back().getd() == 4.5);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
     }
     {
         std::vector<A, stack_allocator<A, 7> > c;
@@ -94,7 +94,7 @@ int main()
         assert(c.size() == 1);
         assert(c.front().geti() == 2);
         assert(c.front().getd() == 3.5);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         i = c.emplace(c.cend(), 3, 4.5);
         assert(i == c.end()-1);
         assert(c.size() == 2);
@@ -102,7 +102,7 @@ int main()
         assert(c.front().getd() == 3.5);
         assert(c.back().geti() == 3);
         assert(c.back().getd() == 4.5);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         i = c.emplace(c.cbegin()+1, 4, 6.5);
         assert(i == c.begin()+1);
         assert(c.size() == 3);
@@ -112,7 +112,7 @@ int main()
         assert(c[1].getd() == 6.5);
         assert(c.back().geti() == 3);
         assert(c.back().getd() == 4.5);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
     }
 #if _LIBCPP_DEBUG >= 1
     {
@@ -122,7 +122,7 @@ int main()
         assert(false);
     }
 #endif
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<A, min_allocator<A>> c;
         std::vector<A, min_allocator<A>>::iterator i = c.emplace(c.cbegin(), 2, 3.5);
diff --git a/test/std/containers/sequences/vector/vector.modifiers/emplace_back.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/emplace_back.pass.cpp
index bbf91a4255d7..61ccade76b02 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/emplace_back.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/emplace_back.pass.cpp
@@ -15,6 +15,7 @@
 #include <cassert>
 #include "../../../stack_allocator.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 #include "asan_testing.h"
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -62,14 +63,14 @@ int main()
         assert(c.size() == 1);
         assert(c.front().geti() == 2);
         assert(c.front().getd() == 3.5);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         c.emplace_back(3, 4.5);
         assert(c.size() == 2);
         assert(c.front().geti() == 2);
         assert(c.front().getd() == 3.5);
         assert(c.back().geti() == 3);
         assert(c.back().getd() == 4.5);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
     }
     {
         std::vector<A, stack_allocator<A, 4> > c;
@@ -77,30 +78,38 @@ int main()
         assert(c.size() == 1);
         assert(c.front().geti() == 2);
         assert(c.front().getd() == 3.5);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         c.emplace_back(3, 4.5);
         assert(c.size() == 2);
         assert(c.front().geti() == 2);
         assert(c.front().getd() == 3.5);
         assert(c.back().geti() == 3);
         assert(c.back().getd() == 4.5);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<A, min_allocator<A>> c;
         c.emplace_back(2, 3.5);
         assert(c.size() == 1);
         assert(c.front().geti() == 2);
         assert(c.front().getd() == 3.5);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         c.emplace_back(3, 4.5);
         assert(c.size() == 2);
         assert(c.front().geti() == 2);
         assert(c.front().getd() == 3.5);
         assert(c.back().geti() == 3);
         assert(c.back().getd() == 4.5);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
+    }
+    {
+        std::vector<Tag_X, TaggingAllocator<Tag_X>> c;
+        c.emplace_back();
+        assert(c.size() == 1);
+        c.emplace_back(1, 2, 3);
+        assert(c.size() == 2);
+        assert(is_contiguous_container_asan_correct(c));
     }
 #endif
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
diff --git a/test/std/containers/sequences/vector/vector.modifiers/emplace_extra.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/emplace_extra.pass.cpp
index 85a47073bcb2..7e4aed8c1b5e 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/emplace_extra.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/emplace_extra.pass.cpp
@@ -23,39 +23,39 @@ int main()
     {
         std::vector<int> v;
         v.reserve(3);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         v = { 1, 2, 3 };
         v.emplace(v.begin(), v.back());
         assert(v[0] == 3);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
     }
     {
         std::vector<int> v;
         v.reserve(4);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         v = { 1, 2, 3 };
         v.emplace(v.begin(), v.back());
         assert(v[0] == 3);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<int, min_allocator<int>> v;
         v.reserve(3);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         v = { 1, 2, 3 };
         v.emplace(v.begin(), v.back());
         assert(v[0] == 3);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
     }
     {
         std::vector<int, min_allocator<int>> v;
         v.reserve(4);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         v = { 1, 2, 3 };
         v.emplace(v.begin(), v.back());
         assert(v[0] == 3);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
     }
 #endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
diff --git a/test/std/containers/sequences/vector/vector.modifiers/erase_iter.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/erase_iter.pass.cpp
index 4fa07b729a75..dbdccf13b72e 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/erase_iter.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/erase_iter.pass.cpp
@@ -24,7 +24,7 @@ int main()
     int a1[] = {1, 2, 3};
     std::vector<int> l1(a1, a1+3);
     std::vector<int>::const_iterator i = l1.begin();
-    assert(is_contiguous_container_asan_correct(l1)); 
+    assert(is_contiguous_container_asan_correct(l1));
     ++i;
     std::vector<int>::iterator j = l1.erase(i);
     assert(l1.size() == 2);
@@ -32,25 +32,25 @@ int main()
     assert(*j == 3);
     assert(*l1.begin() == 1);
     assert(*next(l1.begin()) == 3);
-    assert(is_contiguous_container_asan_correct(l1)); 
+    assert(is_contiguous_container_asan_correct(l1));
     j = l1.erase(j);
     assert(j == l1.end());
     assert(l1.size() == 1);
     assert(distance(l1.begin(), l1.end()) == 1);
     assert(*l1.begin() == 1);
-    assert(is_contiguous_container_asan_correct(l1)); 
+    assert(is_contiguous_container_asan_correct(l1));
     j = l1.erase(l1.begin());
     assert(j == l1.end());
     assert(l1.size() == 0);
     assert(distance(l1.begin(), l1.end()) == 0);
-    assert(is_contiguous_container_asan_correct(l1)); 
+    assert(is_contiguous_container_asan_correct(l1));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     int a1[] = {1, 2, 3};
     std::vector<int, min_allocator<int>> l1(a1, a1+3);
     std::vector<int, min_allocator<int>>::const_iterator i = l1.begin();
-    assert(is_contiguous_container_asan_correct(l1)); 
+    assert(is_contiguous_container_asan_correct(l1));
     ++i;
     std::vector<int, min_allocator<int>>::iterator j = l1.erase(i);
     assert(l1.size() == 2);
@@ -58,18 +58,18 @@ int main()
     assert(*j == 3);
     assert(*l1.begin() == 1);
     assert(*next(l1.begin()) == 3);
-    assert(is_contiguous_container_asan_correct(l1)); 
+    assert(is_contiguous_container_asan_correct(l1));
     j = l1.erase(j);
     assert(j == l1.end());
     assert(l1.size() == 1);
     assert(distance(l1.begin(), l1.end()) == 1);
     assert(*l1.begin() == 1);
-    assert(is_contiguous_container_asan_correct(l1)); 
+    assert(is_contiguous_container_asan_correct(l1));
     j = l1.erase(l1.begin());
     assert(j == l1.end());
     assert(l1.size() == 0);
     assert(distance(l1.begin(), l1.end()) == 0);
-    assert(is_contiguous_container_asan_correct(l1)); 
+    assert(is_contiguous_container_asan_correct(l1));
     }
 #endif
 }
diff --git a/test/std/containers/sequences/vector/vector.modifiers/erase_iter_db1.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/erase_iter_db1.pass.cpp
index 0478d24c79f6..b2c22d6ae696 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/erase_iter_db1.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/erase_iter_db1.pass.cpp
@@ -31,7 +31,7 @@ int main()
     l1.erase(i);
     assert(false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     int a1[] = {1, 2, 3};
     std::vector<int, min_allocator<int>> l1(a1, a1+3);
diff --git a/test/std/containers/sequences/vector/vector.modifiers/erase_iter_db2.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/erase_iter_db2.pass.cpp
index c394f197402b..da0b6d4a059b 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/erase_iter_db2.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/erase_iter_db2.pass.cpp
@@ -32,7 +32,7 @@ int main()
     l1.erase(i);
     assert(false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     int a1[] = {1, 2, 3};
     std::vector<int, min_allocator<int>> l1(a1, a1+3);
diff --git a/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter.pass.cpp
index 2e81d133cde0..f7fa0dba27e8 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter.pass.cpp
@@ -23,106 +23,106 @@ int main()
     int a1[] = {1, 2, 3};
     {
         std::vector<int> l1(a1, a1+3);
-        assert(is_contiguous_container_asan_correct(l1)); 
+        assert(is_contiguous_container_asan_correct(l1));
         std::vector<int>::iterator i = l1.erase(l1.cbegin(), l1.cbegin());
         assert(l1.size() == 3);
         assert(distance(l1.cbegin(), l1.cend()) == 3);
         assert(i == l1.begin());
-        assert(is_contiguous_container_asan_correct(l1)); 
+        assert(is_contiguous_container_asan_correct(l1));
     }
     {
         std::vector<int> l1(a1, a1+3);
-        assert(is_contiguous_container_asan_correct(l1)); 
+        assert(is_contiguous_container_asan_correct(l1));
         std::vector<int>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin()));
         assert(l1.size() == 2);
         assert(distance(l1.cbegin(), l1.cend()) == 2);
         assert(i == l1.begin());
         assert(l1 == std::vector<int>(a1+1, a1+3));
-        assert(is_contiguous_container_asan_correct(l1)); 
+        assert(is_contiguous_container_asan_correct(l1));
     }
     {
         std::vector<int> l1(a1, a1+3);
-        assert(is_contiguous_container_asan_correct(l1)); 
+        assert(is_contiguous_container_asan_correct(l1));
         std::vector<int>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin(), 2));
         assert(l1.size() == 1);
         assert(distance(l1.cbegin(), l1.cend()) == 1);
         assert(i == l1.begin());
         assert(l1 == std::vector<int>(a1+2, a1+3));
-        assert(is_contiguous_container_asan_correct(l1)); 
+        assert(is_contiguous_container_asan_correct(l1));
     }
     {
         std::vector<int> l1(a1, a1+3);
-        assert(is_contiguous_container_asan_correct(l1)); 
+        assert(is_contiguous_container_asan_correct(l1));
         std::vector<int>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin(), 3));
         assert(l1.size() == 0);
         assert(distance(l1.cbegin(), l1.cend()) == 0);
         assert(i == l1.begin());
-        assert(is_contiguous_container_asan_correct(l1)); 
+        assert(is_contiguous_container_asan_correct(l1));
     }
     {
         std::vector<std::vector<int> > outer(2, std::vector<int>(1));
-        assert(is_contiguous_container_asan_correct(outer)); 
-        assert(is_contiguous_container_asan_correct(outer[0])); 
-        assert(is_contiguous_container_asan_correct(outer[1])); 
+        assert(is_contiguous_container_asan_correct(outer));
+        assert(is_contiguous_container_asan_correct(outer[0]));
+        assert(is_contiguous_container_asan_correct(outer[1]));
         outer.erase(outer.begin(), outer.begin());
         assert(outer.size() == 2);
         assert(outer[0].size() == 1);
         assert(outer[1].size() == 1);
-        assert(is_contiguous_container_asan_correct(outer)); 
-        assert(is_contiguous_container_asan_correct(outer[0])); 
-        assert(is_contiguous_container_asan_correct(outer[1])); 
+        assert(is_contiguous_container_asan_correct(outer));
+        assert(is_contiguous_container_asan_correct(outer[0]));
+        assert(is_contiguous_container_asan_correct(outer[1]));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<int, min_allocator<int>> l1(a1, a1+3);
-        assert(is_contiguous_container_asan_correct(l1)); 
+        assert(is_contiguous_container_asan_correct(l1));
         std::vector<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), l1.cbegin());
         assert(l1.size() == 3);
         assert(distance(l1.cbegin(), l1.cend()) == 3);
         assert(i == l1.begin());
-        assert(is_contiguous_container_asan_correct(l1)); 
+        assert(is_contiguous_container_asan_correct(l1));
     }
     {
         std::vector<int, min_allocator<int>> l1(a1, a1+3);
-        assert(is_contiguous_container_asan_correct(l1)); 
+        assert(is_contiguous_container_asan_correct(l1));
         std::vector<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin()));
         assert(l1.size() == 2);
         assert(distance(l1.cbegin(), l1.cend()) == 2);
         assert(i == l1.begin());
         assert((l1 == std::vector<int, min_allocator<int>>(a1+1, a1+3)));
-        assert(is_contiguous_container_asan_correct(l1)); 
+        assert(is_contiguous_container_asan_correct(l1));
     }
     {
         std::vector<int, min_allocator<int>> l1(a1, a1+3);
-        assert(is_contiguous_container_asan_correct(l1)); 
+        assert(is_contiguous_container_asan_correct(l1));
         std::vector<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin(), 2));
         assert(l1.size() == 1);
         assert(distance(l1.cbegin(), l1.cend()) == 1);
         assert(i == l1.begin());
         assert((l1 == std::vector<int, min_allocator<int>>(a1+2, a1+3)));
-        assert(is_contiguous_container_asan_correct(l1)); 
+        assert(is_contiguous_container_asan_correct(l1));
     }
     {
         std::vector<int, min_allocator<int>> l1(a1, a1+3);
-        assert(is_contiguous_container_asan_correct(l1)); 
+        assert(is_contiguous_container_asan_correct(l1));
         std::vector<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin(), 3));
         assert(l1.size() == 0);
         assert(distance(l1.cbegin(), l1.cend()) == 0);
         assert(i == l1.begin());
-        assert(is_contiguous_container_asan_correct(l1)); 
+        assert(is_contiguous_container_asan_correct(l1));
     }
     {
         std::vector<std::vector<int, min_allocator<int>>, min_allocator<std::vector<int, min_allocator<int>>>> outer(2, std::vector<int, min_allocator<int>>(1));
-        assert(is_contiguous_container_asan_correct(outer)); 
-        assert(is_contiguous_container_asan_correct(outer[0])); 
-        assert(is_contiguous_container_asan_correct(outer[1])); 
+        assert(is_contiguous_container_asan_correct(outer));
+        assert(is_contiguous_container_asan_correct(outer[0]));
+        assert(is_contiguous_container_asan_correct(outer[1]));
         outer.erase(outer.begin(), outer.begin());
         assert(outer.size() == 2);
         assert(outer[0].size() == 1);
         assert(outer[1].size() == 1);
-        assert(is_contiguous_container_asan_correct(outer)); 
-        assert(is_contiguous_container_asan_correct(outer[0])); 
-        assert(is_contiguous_container_asan_correct(outer[1])); 
+        assert(is_contiguous_container_asan_correct(outer));
+        assert(is_contiguous_container_asan_correct(outer[0]));
+        assert(is_contiguous_container_asan_correct(outer[1]));
     }
 #endif
 }
diff --git a/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter_db1.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter_db1.pass.cpp
index af6d0f757892..14d3ca803ca3 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter_db1.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter_db1.pass.cpp
@@ -31,7 +31,7 @@ int main()
     std::vector<int>::iterator i = l1.erase(l2.cbegin(), l1.cbegin()+1);
     assert(false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     int a1[] = {1, 2, 3};
     std::vector<int, min_allocator<int>> l1(a1, a1+3);
diff --git a/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter_db2.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter_db2.pass.cpp
index eee2c66c5c8c..04c040a8f797 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter_db2.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter_db2.pass.cpp
@@ -31,7 +31,7 @@ int main()
     std::vector<int>::iterator i = l1.erase(l1.cbegin(), l2.cbegin()+1);
     assert(false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     int a1[] = {1, 2, 3};
     std::vector<int, min_allocator<int>> l1(a1, a1+3);
diff --git a/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter_db3.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter_db3.pass.cpp
index 505067d05a1a..ba183a83f0b1 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter_db3.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter_db3.pass.cpp
@@ -31,7 +31,7 @@ int main()
     std::vector<int>::iterator i = l1.erase(l2.cbegin(), l2.cbegin()+1);
     assert(false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     int a1[] = {1, 2, 3};
     std::vector<int, min_allocator<int>> l1(a1, a1+3);
diff --git a/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter_db4.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter_db4.pass.cpp
index c7e4131cb49c..0fb8071fc679 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter_db4.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter_db4.pass.cpp
@@ -30,7 +30,7 @@ int main()
     std::vector<int>::iterator i = l1.erase(l1.cbegin()+1, l1.cbegin());
     assert(false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     int a1[] = {1, 2, 3};
     std::vector<int, min_allocator<int>> l1(a1, a1+3);
diff --git a/test/std/containers/sequences/vector/vector.modifiers/insert_iter_initializer_list.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/insert_iter_initializer_list.pass.cpp
index 30b801788013..b0fe123aac48 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/insert_iter_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/insert_iter_initializer_list.pass.cpp
@@ -24,7 +24,7 @@ int main()
     std::vector<int> d(10, 1);
     std::vector<int>::iterator i = d.insert(d.cbegin() + 2, {3, 4, 5, 6});
     assert(d.size() == 14);
-    assert(is_contiguous_container_asan_correct(d)); 
+    assert(is_contiguous_container_asan_correct(d));
     assert(i == d.begin() + 2);
     assert(d[0] == 1);
     assert(d[1] == 1);
@@ -41,12 +41,12 @@ int main()
     assert(d[12] == 1);
     assert(d[13] == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     std::vector<int, min_allocator<int>> d(10, 1);
     std::vector<int, min_allocator<int>>::iterator i = d.insert(d.cbegin() + 2, {3, 4, 5, 6});
     assert(d.size() == 14);
-    assert(is_contiguous_container_asan_correct(d)); 
+    assert(is_contiguous_container_asan_correct(d));
     assert(i == d.begin() + 2);
     assert(d[0] == 1);
     assert(d[1] == 1);
diff --git a/test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp
index 782437be87f8..b8953021187f 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp
@@ -32,7 +32,7 @@ int main()
         std::vector<int>::iterator i = v.insert(v.cbegin() + 10, input_iterator<const int*>(a),
                                         input_iterator<const int*>(a+N));
         assert(v.size() == 100 + N);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
         for (j = 0; j < 10; ++j)
@@ -49,7 +49,7 @@ int main()
         std::vector<int>::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const int*>(a),
                                         forward_iterator<const int*>(a+N));
         assert(v.size() == 100 + N);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
         for (j = 0; j < 10; ++j)
@@ -102,7 +102,7 @@ int main()
         std::vector<int>::iterator i = v.insert(v.cbegin() + 10, input_iterator<const int*>(a),
                                         input_iterator<const int*>(a+N));
         assert(v.size() == 100 + N);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
         for (j = 0; j < 10; ++j)
@@ -119,7 +119,7 @@ int main()
         std::vector<int>::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const int*>(a),
                                         forward_iterator<const int*>(a+N));
         assert(v.size() == 100 + N);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
         for (j = 0; j < 10; ++j)
@@ -140,7 +140,7 @@ int main()
         assert(false);
     }
 #endif
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<int, min_allocator<int>> v(100);
         int a[] = {1, 2, 3, 4, 5};
@@ -148,7 +148,7 @@ int main()
         std::vector<int, min_allocator<int>>::iterator i = v.insert(v.cbegin() + 10, input_iterator<const int*>(a),
                                         input_iterator<const int*>(a+N));
         assert(v.size() == 100 + N);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
         for (j = 0; j < 10; ++j)
@@ -165,7 +165,7 @@ int main()
         std::vector<int, min_allocator<int>>::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const int*>(a),
                                         forward_iterator<const int*>(a+N));
         assert(v.size() == 100 + N);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
         for (j = 0; j < 10; ++j)
diff --git a/test/std/containers/sequences/vector/vector.modifiers/insert_iter_rvalue.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/insert_iter_rvalue.pass.cpp
index e12ec45febfc..e1ad6be054e5 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/insert_iter_rvalue.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/insert_iter_rvalue.pass.cpp
@@ -29,7 +29,7 @@ int main()
         std::vector<MoveOnly> v(100);
         std::vector<MoveOnly>::iterator i = v.insert(v.cbegin() + 10, MoveOnly(3));
         assert(v.size() == 101);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
         for (j = 0; j < 10; ++j)
@@ -42,7 +42,7 @@ int main()
         std::vector<MoveOnly, stack_allocator<MoveOnly, 300> > v(100);
         std::vector<MoveOnly, stack_allocator<MoveOnly, 300> >::iterator i = v.insert(v.cbegin() + 10, MoveOnly(3));
         assert(v.size() == 101);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
         for (j = 0; j < 10; ++j)
@@ -59,12 +59,12 @@ int main()
         assert(false);
     }
 #endif
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<MoveOnly, min_allocator<MoveOnly>> v(100);
         std::vector<MoveOnly, min_allocator<MoveOnly>>::iterator i = v.insert(v.cbegin() + 10, MoveOnly(3));
         assert(v.size() == 101);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
         for (j = 0; j < 10; ++j)
diff --git a/test/std/containers/sequences/vector/vector.modifiers/insert_iter_size_value.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/insert_iter_size_value.pass.cpp
index 6997284f258c..ed4d6c976e9c 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/insert_iter_size_value.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/insert_iter_size_value.pass.cpp
@@ -27,7 +27,7 @@ int main()
         std::vector<int> v(100);
         std::vector<int>::iterator i = v.insert(v.cbegin() + 10, 5, 1);
         assert(v.size() == 105);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
         for (j = 0; j < 10; ++j)
@@ -43,7 +43,7 @@ int main()
         size_t sz = v.size();
         std::vector<int>::iterator i = v.insert(v.cbegin() + 10, 5, 1);
         assert(v.size() == sz + 5);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
         for (j = 0; j < 10; ++j)
@@ -59,7 +59,7 @@ int main()
         size_t sz = v.size();
         std::vector<int>::iterator i = v.insert(v.cbegin() + 10, 5, 1);
         assert(v.size() == sz + 5);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
         for (j = 0; j < 10; ++j)
@@ -73,7 +73,7 @@ int main()
         std::vector<int, stack_allocator<int, 300> > v(100);
         std::vector<int, stack_allocator<int, 300> >::iterator i = v.insert(v.cbegin() + 10, 5, 1);
         assert(v.size() == 105);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
         for (j = 0; j < 10; ++j)
@@ -91,12 +91,12 @@ int main()
         assert(false);
     }
 #endif
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<int, min_allocator<int>> v(100);
         std::vector<int, min_allocator<int>>::iterator i = v.insert(v.cbegin() + 10, 5, 1);
         assert(v.size() == 105);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
         for (j = 0; j < 10; ++j)
@@ -110,7 +110,7 @@ int main()
         std::vector<int, min_allocator<int>> v(100);
         std::vector<int, min_allocator<int>>::iterator i = v.insert(v.cbegin() + 10, 5, 1);
         assert(v.size() == 105);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
         for (j = 0; j < 10; ++j)
diff --git a/test/std/containers/sequences/vector/vector.modifiers/insert_iter_value.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/insert_iter_value.pass.cpp
index 782e752157a7..ba030e9e3fb7 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/insert_iter_value.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/insert_iter_value.pass.cpp
@@ -27,7 +27,7 @@ int main()
         std::vector<int> v(100);
         std::vector<int>::iterator i = v.insert(v.cbegin() + 10, 1);
         assert(v.size() == 101);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
         for (j = 0; j < 10; ++j)
@@ -42,7 +42,7 @@ int main()
         size_t sz = v.size();
         std::vector<int>::iterator i = v.insert(v.cbegin() + 10, 1);
         assert(v.size() == sz + 1);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
         for (j = 0; j < 10; ++j)
@@ -58,7 +58,7 @@ int main()
         size_t sz = v.size();
         std::vector<int>::iterator i = v.insert(v.cbegin() + 10, 1);
         assert(v.size() == sz + 1);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
         for (j = 0; j < 10; ++j)
@@ -71,7 +71,7 @@ int main()
         std::vector<int, stack_allocator<int, 300> > v(100);
         std::vector<int, stack_allocator<int, 300> >::iterator i = v.insert(v.cbegin() + 10, 1);
         assert(v.size() == 101);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
         for (j = 0; j < 10; ++j)
@@ -89,12 +89,12 @@ int main()
         assert(false);
     }
 #endif
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<int, min_allocator<int>> v(100);
         std::vector<int, min_allocator<int>>::iterator i = v.insert(v.cbegin() + 10, 1);
         assert(v.size() == 101);
-        assert(is_contiguous_container_asan_correct(v)); 
+        assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
         for (j = 0; j < 10; ++j)
diff --git a/test/std/containers/sequences/vector/vector.modifiers/pop_back.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/pop_back.pass.cpp
index 62fa60103baa..c81e41904fc8 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/pop_back.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/pop_back.pass.cpp
@@ -37,9 +37,9 @@ int main()
 #if _LIBCPP_DEBUG >= 1
         c.pop_back();
         assert(false);
-#endif        
+#endif
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<int, min_allocator<int>> c;
         c.push_back(1);
@@ -49,7 +49,7 @@ int main()
 #if _LIBCPP_DEBUG >= 1
         c.pop_back();
         assert(false);
-#endif        
+#endif
     }
-#endif        
+#endif
 }
diff --git a/test/std/containers/sequences/vector/vector.modifiers/push_back.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/push_back.pass.cpp
index eeeba6242d93..bef3b9c8d17d 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/push_back.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/push_back.pass.cpp
@@ -23,27 +23,27 @@ int main()
         std::vector<int> c;
         c.push_back(0);
         assert(c.size() == 1);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == j);
         c.push_back(1);
         assert(c.size() == 2);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == j);
         c.push_back(2);
         assert(c.size() == 3);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == j);
         c.push_back(3);
         assert(c.size() == 4);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == j);
         c.push_back(4);
         assert(c.size() == 5);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == j);
     }
@@ -51,56 +51,56 @@ int main()
         std::vector<int, stack_allocator<int, 15> > c;
         c.push_back(0);
         assert(c.size() == 1);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == j);
         c.push_back(1);
         assert(c.size() == 2);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == j);
         c.push_back(2);
         assert(c.size() == 3);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == j);
         c.push_back(3);
         assert(c.size() == 4);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == j);
         c.push_back(4);
         assert(c.size() == 5);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == j);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<int, min_allocator<int>> c;
         c.push_back(0);
         assert(c.size() == 1);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == j);
         c.push_back(1);
         assert(c.size() == 2);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == j);
         c.push_back(2);
         assert(c.size() == 3);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == j);
         c.push_back(3);
         assert(c.size() == 4);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == j);
         c.push_back(4);
         assert(c.size() == 5);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == j);
     }
diff --git a/test/std/containers/sequences/vector/vector.modifiers/push_back_exception_safety.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/push_back_exception_safety.pass.cpp
index 785225357d4b..5fa93aab89c7 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/push_back_exception_safety.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/push_back_exception_safety.pass.cpp
@@ -31,7 +31,7 @@ class CMyClass {
     private:
         int fMagicValue;
         int fTag;
-        
+
     private: static int kStartedConstructionMagicValue;
     private: static int kFinishedConstructionMagicValue;
 };
@@ -73,8 +73,8 @@ int main()
 
     vec.push_back(instance);
     std::vector<CMyClass> vec2(vec);
-    assert(is_contiguous_container_asan_correct(vec)); 
-    assert(is_contiguous_container_asan_correct(vec2)); 
+    assert(is_contiguous_container_asan_correct(vec));
+    assert(is_contiguous_container_asan_correct(vec2));
 
     gCopyConstructorShouldThow = true;
     try {
@@ -82,6 +82,6 @@ int main()
     }
     catch (...) {
         assert(vec==vec2);
-        assert(is_contiguous_container_asan_correct(vec)); 
+        assert(is_contiguous_container_asan_correct(vec));
     }
 }
diff --git a/test/std/containers/sequences/vector/vector.modifiers/push_back_rvalue.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/push_back_rvalue.pass.cpp
index b143cd773b42..64762eb374e8 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/push_back_rvalue.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/push_back_rvalue.pass.cpp
@@ -25,27 +25,27 @@ int main()
         std::vector<MoveOnly> c;
         c.push_back(MoveOnly(0));
         assert(c.size() == 1);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
         c.push_back(MoveOnly(1));
         assert(c.size() == 2);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
         c.push_back(MoveOnly(2));
         assert(c.size() == 3);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
         c.push_back(MoveOnly(3));
         assert(c.size() == 4);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
         c.push_back(MoveOnly(4));
         assert(c.size() == 5);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
     }
@@ -53,56 +53,56 @@ int main()
         std::vector<MoveOnly, stack_allocator<MoveOnly, 15> > c;
         c.push_back(MoveOnly(0));
         assert(c.size() == 1);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
         c.push_back(MoveOnly(1));
         assert(c.size() == 2);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
         c.push_back(MoveOnly(2));
         assert(c.size() == 3);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
         c.push_back(MoveOnly(3));
         assert(c.size() == 4);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
         c.push_back(MoveOnly(4));
         assert(c.size() == 5);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::vector<MoveOnly, min_allocator<MoveOnly>> c;
         c.push_back(MoveOnly(0));
         assert(c.size() == 1);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
         c.push_back(MoveOnly(1));
         assert(c.size() == 2);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
         c.push_back(MoveOnly(2));
         assert(c.size() == 3);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
         c.push_back(MoveOnly(3));
         assert(c.size() == 4);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
         c.push_back(MoveOnly(4));
         assert(c.size() == 5);
-        assert(is_contiguous_container_asan_correct(c)); 
+        assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
     }
diff --git a/test/std/containers/sequences/vector/vector.special/db_swap_1.pass.cpp b/test/std/containers/sequences/vector/vector.special/db_swap_1.pass.cpp
index e7f6a0011e1a..1bb761181422 100644
--- a/test/std/containers/sequences/vector/vector.special/db_swap_1.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.special/db_swap_1.pass.cpp
@@ -37,7 +37,7 @@ int main()
         c1.erase(i1);
         assert(false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         int a1[] = {1, 3, 7, 9, 10};
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
diff --git a/test/std/containers/sequences/vector/vector.special/swap.pass.cpp b/test/std/containers/sequences/vector/vector.special/swap.pass.cpp
index 96aaf7131f53..3d01129fa008 100644
--- a/test/std/containers/sequences/vector/vector.special/swap.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.special/swap.pass.cpp
@@ -26,56 +26,56 @@ int main()
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
         std::vector<int> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
         std::vector<int> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
-        assert(is_contiguous_container_asan_correct(c1)); 
-        assert(is_contiguous_container_asan_correct(c2)); 
+        assert(is_contiguous_container_asan_correct(c1));
+        assert(is_contiguous_container_asan_correct(c2));
         swap(c1, c2);
         assert(c1 == std::vector<int>(a2, a2+sizeof(a2)/sizeof(a2[0])));
         assert(c2 == std::vector<int>(a1, a1+sizeof(a1)/sizeof(a1[0])));
-        assert(is_contiguous_container_asan_correct(c1)); 
-        assert(is_contiguous_container_asan_correct(c2)); 
+        assert(is_contiguous_container_asan_correct(c1));
+        assert(is_contiguous_container_asan_correct(c2));
     }
     {
         int a1[] = {1, 3, 7, 9, 10};
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
         std::vector<int> c1(a1, a1);
         std::vector<int> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
-        assert(is_contiguous_container_asan_correct(c1)); 
-        assert(is_contiguous_container_asan_correct(c2)); 
+        assert(is_contiguous_container_asan_correct(c1));
+        assert(is_contiguous_container_asan_correct(c2));
         swap(c1, c2);
         assert(c1 == std::vector<int>(a2, a2+sizeof(a2)/sizeof(a2[0])));
         assert(c2.empty());
         assert(distance(c2.begin(), c2.end()) == 0);
-        assert(is_contiguous_container_asan_correct(c1)); 
-        assert(is_contiguous_container_asan_correct(c2)); 
+        assert(is_contiguous_container_asan_correct(c1));
+        assert(is_contiguous_container_asan_correct(c2));
     }
     {
         int a1[] = {1, 3, 7, 9, 10};
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
         std::vector<int> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
         std::vector<int> c2(a2, a2);
-        assert(is_contiguous_container_asan_correct(c1)); 
-        assert(is_contiguous_container_asan_correct(c2)); 
+        assert(is_contiguous_container_asan_correct(c1));
+        assert(is_contiguous_container_asan_correct(c2));
         swap(c1, c2);
         assert(c1.empty());
         assert(distance(c1.begin(), c1.end()) == 0);
         assert(c2 == std::vector<int>(a1, a1+sizeof(a1)/sizeof(a1[0])));
-        assert(is_contiguous_container_asan_correct(c1)); 
-        assert(is_contiguous_container_asan_correct(c2)); 
+        assert(is_contiguous_container_asan_correct(c1));
+        assert(is_contiguous_container_asan_correct(c2));
     }
     {
         int a1[] = {1, 3, 7, 9, 10};
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
         std::vector<int> c1(a1, a1);
         std::vector<int> c2(a2, a2);
-        assert(is_contiguous_container_asan_correct(c1)); 
-        assert(is_contiguous_container_asan_correct(c2)); 
+        assert(is_contiguous_container_asan_correct(c1));
+        assert(is_contiguous_container_asan_correct(c2));
         swap(c1, c2);
         assert(c1.empty());
         assert(distance(c1.begin(), c1.end()) == 0);
         assert(c2.empty());
         assert(distance(c2.begin(), c2.end()) == 0);
-        assert(is_contiguous_container_asan_correct(c1)); 
-        assert(is_contiguous_container_asan_correct(c2)); 
+        assert(is_contiguous_container_asan_correct(c1));
+        assert(is_contiguous_container_asan_correct(c2));
     }
 #ifndef _LIBCPP_DEBUG_LEVEL
 // This test known to result in undefined behavior detected by _LIBCPP_DEBUG_LEVEL >= 1
@@ -98,72 +98,72 @@ int main()
         typedef other_allocator<int> A;
         std::vector<int, A> c1(a1, a1+sizeof(a1)/sizeof(a1[0]), A(1));
         std::vector<int, A> c2(a2, a2+sizeof(a2)/sizeof(a2[0]), A(2));
-        assert(is_contiguous_container_asan_correct(c1)); 
-        assert(is_contiguous_container_asan_correct(c2)); 
+        assert(is_contiguous_container_asan_correct(c1));
+        assert(is_contiguous_container_asan_correct(c2));
         swap(c1, c2);
         assert((c1 == std::vector<int, A>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
         assert(c1.get_allocator() == A(2));
         assert((c2 == std::vector<int, A>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
         assert(c2.get_allocator() == A(1));
-        assert(is_contiguous_container_asan_correct(c1)); 
-        assert(is_contiguous_container_asan_correct(c2)); 
+        assert(is_contiguous_container_asan_correct(c1));
+        assert(is_contiguous_container_asan_correct(c2));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         int a1[] = {1, 3, 7, 9, 10};
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
         std::vector<int, min_allocator<int>> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
         std::vector<int, min_allocator<int>> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
-        assert(is_contiguous_container_asan_correct(c1)); 
-        assert(is_contiguous_container_asan_correct(c2)); 
+        assert(is_contiguous_container_asan_correct(c1));
+        assert(is_contiguous_container_asan_correct(c2));
         swap(c1, c2);
         assert((c1 == std::vector<int, min_allocator<int>>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
         assert((c2 == std::vector<int, min_allocator<int>>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
-        assert(is_contiguous_container_asan_correct(c1)); 
-        assert(is_contiguous_container_asan_correct(c2)); 
+        assert(is_contiguous_container_asan_correct(c1));
+        assert(is_contiguous_container_asan_correct(c2));
     }
     {
         int a1[] = {1, 3, 7, 9, 10};
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
         std::vector<int, min_allocator<int>> c1(a1, a1);
         std::vector<int, min_allocator<int>> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
-        assert(is_contiguous_container_asan_correct(c1)); 
-        assert(is_contiguous_container_asan_correct(c2)); 
+        assert(is_contiguous_container_asan_correct(c1));
+        assert(is_contiguous_container_asan_correct(c2));
         swap(c1, c2);
         assert((c1 == std::vector<int, min_allocator<int>>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
         assert(c2.empty());
         assert(distance(c2.begin(), c2.end()) == 0);
-        assert(is_contiguous_container_asan_correct(c1)); 
-        assert(is_contiguous_container_asan_correct(c2)); 
+        assert(is_contiguous_container_asan_correct(c1));
+        assert(is_contiguous_container_asan_correct(c2));
     }
     {
         int a1[] = {1, 3, 7, 9, 10};
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
         std::vector<int, min_allocator<int>> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
         std::vector<int, min_allocator<int>> c2(a2, a2);
-        assert(is_contiguous_container_asan_correct(c1)); 
-        assert(is_contiguous_container_asan_correct(c2)); 
+        assert(is_contiguous_container_asan_correct(c1));
+        assert(is_contiguous_container_asan_correct(c2));
         swap(c1, c2);
         assert(c1.empty());
         assert(distance(c1.begin(), c1.end()) == 0);
         assert((c2 == std::vector<int, min_allocator<int>>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
-        assert(is_contiguous_container_asan_correct(c1)); 
-        assert(is_contiguous_container_asan_correct(c2)); 
+        assert(is_contiguous_container_asan_correct(c1));
+        assert(is_contiguous_container_asan_correct(c2));
     }
     {
         int a1[] = {1, 3, 7, 9, 10};
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
         std::vector<int, min_allocator<int>> c1(a1, a1);
         std::vector<int, min_allocator<int>> c2(a2, a2);
-        assert(is_contiguous_container_asan_correct(c1)); 
-        assert(is_contiguous_container_asan_correct(c2)); 
+        assert(is_contiguous_container_asan_correct(c1));
+        assert(is_contiguous_container_asan_correct(c2));
         swap(c1, c2);
         assert(c1.empty());
         assert(distance(c1.begin(), c1.end()) == 0);
         assert(c2.empty());
         assert(distance(c2.begin(), c2.end()) == 0);
-        assert(is_contiguous_container_asan_correct(c1)); 
-        assert(is_contiguous_container_asan_correct(c2)); 
+        assert(is_contiguous_container_asan_correct(c1));
+        assert(is_contiguous_container_asan_correct(c2));
     }
 #ifndef _LIBCPP_DEBUG_LEVEL
 // This test known to result in undefined behavior detected by _LIBCPP_DEBUG_LEVEL >= 1
@@ -173,15 +173,15 @@ int main()
         typedef min_allocator<int> A;
         std::vector<int, A> c1(a1, a1+sizeof(a1)/sizeof(a1[0]), A());
         std::vector<int, A> c2(a2, a2+sizeof(a2)/sizeof(a2[0]), A());
-        assert(is_contiguous_container_asan_correct(c1)); 
-        assert(is_contiguous_container_asan_correct(c2)); 
+        assert(is_contiguous_container_asan_correct(c1));
+        assert(is_contiguous_container_asan_correct(c2));
         swap(c1, c2);
         assert((c1 == std::vector<int, A>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
         assert(c1.get_allocator() == A());
         assert((c2 == std::vector<int, A>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
         assert(c2.get_allocator() == A());
-        assert(is_contiguous_container_asan_correct(c1)); 
-        assert(is_contiguous_container_asan_correct(c2)); 
+        assert(is_contiguous_container_asan_correct(c1));
+        assert(is_contiguous_container_asan_correct(c2));
     }
 #endif
 #endif
diff --git a/test/std/containers/sequences/vector/vector.special/swap_noexcept.pass.cpp b/test/std/containers/sequences/vector/vector.special/swap_noexcept.pass.cpp
index 1d00ff387480..89fa301ad9bd 100644
--- a/test/std/containers/sequences/vector/vector.special/swap_noexcept.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.special/swap_noexcept.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <vector>
 
 // void swap(vector& c)
@@ -22,6 +24,7 @@
 #include <vector>
 #include <cassert>
 
+#include "test_macros.h"
 #include "MoveOnly.h"
 #include "test_allocator.h"
 
@@ -29,7 +32,7 @@ template <class T>
 struct some_alloc
 {
     typedef T value_type;
-    
+
     some_alloc() {}
     some_alloc(const some_alloc&);
     void deallocate(void*, unsigned) {}
@@ -41,7 +44,7 @@ template <class T>
 struct some_alloc2
 {
     typedef T value_type;
-    
+
     some_alloc2() {}
     some_alloc2(const some_alloc2&);
     void deallocate(void*, unsigned) {}
@@ -52,7 +55,6 @@ struct some_alloc2
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::vector<MoveOnly> C;
         C c1, c2;
@@ -86,6 +88,4 @@ int main()
         static_assert( noexcept(swap(c1, c2)), "");
     }
 #endif
-
-#endif
 }
diff --git a/test/std/containers/set_allocator_requirement_test_templates.h b/test/std/containers/set_allocator_requirement_test_templates.h
new file mode 100644
index 000000000000..2e3346f47e2d
--- /dev/null
+++ b/test/std/containers/set_allocator_requirement_test_templates.h
@@ -0,0 +1,354 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+#ifndef SET_ALLOCATOR_REQUIREMENT_TEST_TEMPLATES_H
+#define SET_ALLOCATOR_REQUIREMENT_TEST_TEMPLATES_H
+
+// <set>
+// <unordered_set>
+
+// class set
+// class unordered_set
+
+// insert(...);
+// emplace(...);
+// emplace_hint(...);
+
+
+#include <cassert>
+
+#include "test_macros.h"
+#include "count_new.hpp"
+#include "container_test_types.h"
+#include "assert_checkpoint.h"
+
+
+template <class Container>
+void testSetInsert()
+{
+  typedef typename Container::value_type ValueTp;
+  typedef Container C;
+  typedef std::pair<typename C::iterator, bool> R;
+  ConstructController* cc = getConstructController();
+  cc->reset();
+  {
+    CHECKPOINT("Testing C::insert(const value_type&)");
+    Container c;
+    const ValueTp v(42);
+    cc->expect<const ValueTp&>();
+    assert(c.insert(v).second);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      const ValueTp v2(42);
+      assert(c.insert(v2).second == false);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::insert(value_type&)");
+    Container c;
+    ValueTp v(42);
+    cc->expect<const ValueTp&>();
+    assert(c.insert(v).second);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      ValueTp v2(42);
+      assert(c.insert(v2).second == false);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::insert(value_type&&)");
+    Container c;
+    ValueTp v(42);
+    cc->expect<ValueTp&&>();
+    assert(c.insert(std::move(v)).second);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      ValueTp v2(42);
+      assert(c.insert(std::move(v2)).second == false);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::insert(const value_type&&)");
+    Container c;
+    const ValueTp v(42);
+    cc->expect<const ValueTp&>();
+    assert(c.insert(std::move(v)).second);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      const ValueTp v2(42);
+      assert(c.insert(std::move(v2)).second == false);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::insert(std::initializer_list<ValueTp>)");
+    Container c;
+    std::initializer_list<ValueTp> il = { ValueTp(1), ValueTp(2) };
+    cc->expect<ValueTp const&>(2);
+    c.insert(il);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      c.insert(il);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::insert(Iter, Iter) for *Iter = value_type const&");
+    Container c;
+    const ValueTp ValueList[] = { ValueTp(1), ValueTp(2), ValueTp(3) };
+    cc->expect<ValueTp const&>(3);
+    c.insert(std::begin(ValueList), std::end(ValueList));
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      c.insert(std::begin(ValueList), std::end(ValueList));
+    }
+  }
+  {
+    CHECKPOINT("Testing C::insert(Iter, Iter) for *Iter = value_type&&");
+    Container c;
+    ValueTp ValueList[] = { ValueTp(1), ValueTp(2) , ValueTp(3) };
+    cc->expect<ValueTp&&>(3);
+    c.insert(std::move_iterator<ValueTp*>(std::begin(ValueList)),
+             std::move_iterator<ValueTp*>(std::end(ValueList)));
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      ValueTp ValueList2[] = { ValueTp(1), ValueTp(2) , ValueTp(3) };
+      c.insert(std::move_iterator<ValueTp*>(std::begin(ValueList2)),
+               std::move_iterator<ValueTp*>(std::end(ValueList2)));
+    }
+  }
+  {
+    CHECKPOINT("Testing C::insert(Iter, Iter) for *Iter = value_type&");
+    Container c;
+    ValueTp ValueList[] = { ValueTp(1), ValueTp(2) , ValueTp(3) };
+    cc->expect<ValueTp const&>(3);
+    c.insert(std::begin(ValueList), std::end(ValueList));
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      c.insert(std::begin(ValueList), std::end(ValueList));
+    }
+  }
+}
+
+
+template <class Container>
+void testSetEmplace()
+{
+  typedef typename Container::value_type ValueTp;
+  typedef Container C;
+  typedef std::pair<typename C::iterator, bool> R;
+  ConstructController* cc = getConstructController();
+  cc->reset();
+  {
+    CHECKPOINT("Testing C::emplace(const value_type&)");
+    Container c;
+    const ValueTp v(42);
+    cc->expect<const ValueTp&>();
+    assert(c.emplace(v).second);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      const ValueTp v2(42);
+      assert(c.emplace(v2).second == false);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::emplace(value_type&)");
+    Container c;
+    ValueTp v(42);
+    cc->expect<ValueTp&>();
+    assert(c.emplace(v).second);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      ValueTp v2(42);
+      assert(c.emplace(v2).second == false);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::emplace(value_type&&)");
+    Container c;
+    ValueTp v(42);
+    cc->expect<ValueTp&&>();
+    assert(c.emplace(std::move(v)).second);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      ValueTp v2(42);
+      assert(c.emplace(std::move(v2)).second == false);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::emplace(const value_type&&)");
+    Container c;
+    const ValueTp v(42);
+    cc->expect<const ValueTp&&>();
+    assert(c.emplace(std::move(v)).second);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      const ValueTp v2(42);
+      assert(c.emplace(std::move(v2)).second == false);
+    }
+  }
+}
+
+
+template <class Container>
+void testSetEmplaceHint()
+{
+  typedef typename Container::value_type ValueTp;
+
+  typedef Container C;
+  typedef typename C::iterator It;
+  ConstructController* cc = getConstructController();
+  cc->reset();
+  {
+    CHECKPOINT("Testing C::emplace_hint(p, const value_type&)");
+    Container c;
+    const ValueTp v(42);
+    cc->expect<const ValueTp&>();
+    It ret = c.emplace_hint(c.end(), v);
+    assert(ret != c.end());
+    assert(c.size() == 1);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      const ValueTp v2(42);
+      It ret2 = c.emplace_hint(c.begin(), v2);
+      assert(&(*ret2) == &(*ret));
+      assert(c.size() == 1);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::emplace_hint(p, value_type&)");
+    Container c;
+    ValueTp v(42);
+    cc->expect<ValueTp&>();
+    It ret = c.emplace_hint(c.end(), v);
+    assert(ret != c.end());
+    assert(c.size() == 1);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      ValueTp v2(42);
+      It ret2 = c.emplace_hint(c.begin(), v2);
+      assert(&(*ret2) == &(*ret));
+      assert(c.size() == 1);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::emplace_hint(p, value_type&&)");
+    Container c;
+    ValueTp v(42);
+    cc->expect<ValueTp&&>();
+    It ret = c.emplace_hint(c.end(), std::move(v));
+    assert(ret != c.end());
+    assert(c.size() == 1);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      ValueTp v2(42);
+      It ret2 = c.emplace_hint(c.begin(), std::move(v2));
+      assert(&(*ret2) == &(*ret));
+      assert(c.size() == 1);
+    }
+  }
+  {
+    CHECKPOINT("Testing C::emplace_hint(p, const value_type&&)");
+    Container c;
+    const ValueTp v(42);
+    cc->expect<const ValueTp&&>();
+    It ret = c.emplace_hint(c.end(), std::move(v));
+    assert(ret != c.end());
+    assert(c.size() == 1);
+    assert(!cc->unchecked());
+    {
+      DisableAllocationGuard g;
+      const ValueTp v2(42);
+      It ret2 = c.emplace_hint(c.begin(), std::move(v2));
+      assert(&(*ret2) == &(*ret));
+      assert(c.size() == 1);
+    }
+  }
+}
+
+
+template <class Container>
+void testMultisetInsert()
+{
+  typedef typename Container::value_type ValueTp;
+  typedef Container C;
+  ConstructController* cc = getConstructController();
+  cc->reset();
+  {
+    CHECKPOINT("Testing C::insert(const value_type&)");
+    Container c;
+    const ValueTp v(42);
+    cc->expect<const ValueTp&>();
+    c.insert(v);
+    assert(!cc->unchecked());
+  }
+  {
+    CHECKPOINT("Testing C::insert(value_type&)");
+    Container c;
+    ValueTp v(42);
+    cc->expect<const ValueTp&>();
+    c.insert(v);
+    assert(!cc->unchecked());
+  }
+  {
+    CHECKPOINT("Testing C::insert(value_type&&)");
+    Container c;
+    ValueTp v(42);
+    cc->expect<ValueTp&&>();
+    c.insert(std::move(v));
+    assert(!cc->unchecked());
+  }
+  {
+    CHECKPOINT("Testing C::insert(std::initializer_list<ValueTp>)");
+    Container c;
+    std::initializer_list<ValueTp> il = { ValueTp(1), ValueTp(2) };
+    cc->expect<ValueTp const&>(2);
+    c.insert(il);
+    assert(!cc->unchecked());
+  }
+  {
+    CHECKPOINT("Testing C::insert(Iter, Iter) for *Iter = value_type const&");
+    Container c;
+    const ValueTp ValueList[] = { ValueTp(1), ValueTp(2), ValueTp(3) };
+    cc->expect<ValueTp const&>(3);
+    c.insert(std::begin(ValueList), std::end(ValueList));
+    assert(!cc->unchecked());
+  }
+  {
+    CHECKPOINT("Testing C::insert(Iter, Iter) for *Iter = value_type&&");
+    Container c;
+    ValueTp ValueList[] = { ValueTp(1), ValueTp(2) , ValueTp(3) };
+    cc->expect<ValueTp&&>(3);
+    c.insert(std::move_iterator<ValueTp*>(std::begin(ValueList)),
+             std::move_iterator<ValueTp*>(std::end(ValueList)));
+    assert(!cc->unchecked());
+  }
+  {
+    CHECKPOINT("Testing C::insert(Iter, Iter) for *Iter = value_type&");
+    Container c;
+    ValueTp ValueList[] = { ValueTp(1), ValueTp(2) , ValueTp(3) };
+    cc->expect<ValueTp&>(3);
+    c.insert(std::begin(ValueList), std::end(ValueList));
+    assert(!cc->unchecked());
+  }
+}
+
+#endif
diff --git a/test/std/containers/unord/iterator_difference_type.pass.cpp b/test/std/containers/unord/iterator_difference_type.pass.cpp
new file mode 100644
index 000000000000..35bcc27944db
--- /dev/null
+++ b/test/std/containers/unord/iterator_difference_type.pass.cpp
@@ -0,0 +1,154 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+#include <unordered_map>
+#include <unordered_set>
+#include <type_traits>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+#include "test_allocator.h"
+
+
+template <class Map, class ValueTp, class PtrT, class CPtrT>
+void testUnorderedMap() {
+  typedef typename Map::difference_type Diff;
+  {
+    typedef typename Map::iterator It;
+    static_assert((std::is_same<typename It::value_type, ValueTp>::value), "");
+    static_assert((std::is_same<typename It::reference, ValueTp&>::value), "");
+    static_assert((std::is_same<typename It::pointer, PtrT>::value), "");
+    static_assert((std::is_same<typename It::difference_type, Diff>::value), "");
+  }
+  {
+    typedef typename Map::const_iterator It;
+    static_assert((std::is_same<typename It::value_type, ValueTp>::value), "");
+    static_assert((std::is_same<typename It::reference, ValueTp const&>::value), "");
+    static_assert((std::is_same<typename It::pointer, CPtrT>::value), "");
+    static_assert((std::is_same<typename It::difference_type, Diff>::value), "");
+  }
+  {
+    typedef typename Map::local_iterator It;
+    static_assert((std::is_same<typename It::value_type, ValueTp>::value), "");
+    static_assert((std::is_same<typename It::reference, ValueTp&>::value), "");
+    static_assert((std::is_same<typename It::pointer, PtrT>::value), "");
+    static_assert((std::is_same<typename It::difference_type, Diff>::value), "");
+  }
+  {
+    typedef typename Map::const_local_iterator It;
+    static_assert((std::is_same<typename It::value_type, ValueTp>::value), "");
+    static_assert((std::is_same<typename It::reference, ValueTp const&>::value), "");
+    static_assert((std::is_same<typename It::pointer, CPtrT>::value), "");
+    static_assert((std::is_same<typename It::difference_type, Diff>::value), "");
+  }
+}
+
+
+template <class Set, class ValueTp, class CPtrT>
+void testUnorderedSet() {
+  static_assert((std::is_same<typename Set::iterator,
+                             typename Set::const_iterator>::value), "");
+  static_assert((std::is_same<typename Set::local_iterator,
+                             typename Set::const_local_iterator>::value), "");
+  typedef typename Set::difference_type Diff;
+  {
+    typedef typename Set::iterator It;
+    static_assert((std::is_same<typename It::value_type, ValueTp>::value), "");
+    static_assert((std::is_same<typename It::reference, ValueTp const&>::value), "");
+    static_assert((std::is_same<typename It::pointer, CPtrT>::value), "");
+    static_assert((std::is_same<typename It::difference_type, Diff>::value), "");
+
+  }
+  {
+    typedef typename Set::local_iterator It;
+    static_assert((std::is_same<typename It::value_type, ValueTp>::value), "");
+    static_assert((std::is_same<typename It::reference, ValueTp const&>::value), "");
+    static_assert((std::is_same<typename It::pointer, CPtrT>::value), "");
+    static_assert((std::is_same<typename It::difference_type, Diff>::value), "");
+  }
+}
+
+int main() {
+  {
+    typedef std::unordered_map<int, int> Map;
+    typedef std::pair<const int, int> ValueTp;
+    testUnorderedMap<Map, ValueTp, ValueTp*, ValueTp const*>();
+  }
+  {
+    typedef std::pair<const int, int> ValueTp;
+    typedef test_allocator<ValueTp> Alloc;
+    typedef std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, Alloc> Map;
+    testUnorderedMap<Map, ValueTp, ValueTp*, ValueTp const*>();
+  }
+#if TEST_STD_VER >= 11
+  {
+    typedef std::pair<const int, int> ValueTp;
+    typedef min_allocator<ValueTp> Alloc;
+    typedef std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, Alloc> Map;
+    testUnorderedMap<Map, ValueTp, min_pointer<ValueTp>, min_pointer<const ValueTp>>();
+  }
+#endif
+  {
+    typedef std::unordered_multimap<int, int> Map;
+    typedef std::pair<const int, int> ValueTp;
+    testUnorderedMap<Map, ValueTp, ValueTp*, ValueTp const*>();
+  }
+  {
+    typedef std::pair<const int, int> ValueTp;
+    typedef test_allocator<ValueTp> Alloc;
+    typedef std::unordered_multimap<int, int, std::hash<int>, std::equal_to<int>, Alloc> Map;
+    testUnorderedMap<Map, ValueTp, ValueTp*, ValueTp const*>();
+  }
+#if TEST_STD_VER >= 11
+  {
+    typedef std::pair<const int, int> ValueTp;
+    typedef min_allocator<ValueTp> Alloc;
+    typedef std::unordered_multimap<int, int, std::hash<int>, std::equal_to<int>, Alloc> Map;
+    testUnorderedMap<Map, ValueTp, min_pointer<ValueTp>, min_pointer<const ValueTp>>();
+  }
+#endif
+  {
+    typedef int ValueTp;
+    typedef std::unordered_set<ValueTp> Set;
+    testUnorderedSet<Set, ValueTp, ValueTp const*>();
+  }
+  {
+    typedef int ValueTp;
+    typedef test_allocator<ValueTp> Alloc;
+    typedef std::unordered_set<ValueTp, std::hash<ValueTp>, std::equal_to<ValueTp>, Alloc> Set;
+    testUnorderedSet<Set, ValueTp, ValueTp const*>();
+  }
+#if TEST_STD_VER >= 11
+  {
+    typedef int ValueTp;
+    typedef min_allocator<ValueTp> Alloc;
+    typedef std::unordered_set<ValueTp, std::hash<ValueTp>, std::equal_to<ValueTp>, Alloc> Set;
+    testUnorderedSet<Set, ValueTp, min_pointer<const ValueTp>>();
+  }
+#endif
+  {
+    typedef int ValueTp;
+    typedef std::unordered_multiset<ValueTp> Set;
+    testUnorderedSet<Set, ValueTp, ValueTp const*>();
+  }
+  {
+    typedef int ValueTp;
+    typedef test_allocator<ValueTp> Alloc;
+    typedef std::unordered_multiset<ValueTp, std::hash<ValueTp>, std::equal_to<ValueTp>, Alloc> Set;
+    testUnorderedSet<Set, ValueTp, ValueTp const*>();
+  }
+#if TEST_STD_VER >= 11
+  {
+    typedef int ValueTp;
+    typedef min_allocator<ValueTp> Alloc;
+    typedef std::unordered_multiset<ValueTp, std::hash<ValueTp>, std::equal_to<ValueTp>, Alloc> Set;
+    testUnorderedSet<Set, ValueTp, min_pointer<const ValueTp>>();
+  }
+#endif
+}
diff --git a/test/std/containers/unord/unord.map/bucket.pass.cpp b/test/std/containers/unord/unord.map/bucket.pass.cpp
index 6837294e35bc..1abb58070afd 100644
--- a/test/std/containers/unord/unord.map/bucket.pass.cpp
+++ b/test/std/containers/unord/unord.map/bucket.pass.cpp
@@ -45,7 +45,7 @@ int main()
         for (size_t i = 0; i < 13; ++i)
             assert(c.bucket(i) == i % bc);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.map/bucket_size.pass.cpp b/test/std/containers/unord/unord.map/bucket_size.pass.cpp
index f3ab8fff4e43..4344508b7334 100644
--- a/test/std/containers/unord/unord.map/bucket_size.pass.cpp
+++ b/test/std/containers/unord/unord.map/bucket_size.pass.cpp
@@ -47,7 +47,7 @@ int main()
         assert(c.bucket_size(3) == 1);
         assert(c.bucket_size(4) == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.map/count.pass.cpp b/test/std/containers/unord/unord.map/count.pass.cpp
index 50abb53464ec..68661b56de1c 100644
--- a/test/std/containers/unord/unord.map/count.pass.cpp
+++ b/test/std/containers/unord/unord.map/count.pass.cpp
@@ -41,7 +41,7 @@ int main()
         assert(c.count(30) == 1);
         assert(c.count(5) == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.map/eq.pass.cpp b/test/std/containers/unord/unord.map/eq.pass.cpp
index 9258378eb09a..5dcea6a73f28 100644
--- a/test/std/containers/unord/unord.map/eq.pass.cpp
+++ b/test/std/containers/unord/unord.map/eq.pass.cpp
@@ -91,7 +91,7 @@ int main()
         assert( (c1 == c2));
         assert(!(c1 != c2));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.map/equal_range_const.pass.cpp b/test/std/containers/unord/unord.map/equal_range_const.pass.cpp
index fe166c965b16..46e04fde2b32 100644
--- a/test/std/containers/unord/unord.map/equal_range_const.pass.cpp
+++ b/test/std/containers/unord/unord.map/equal_range_const.pass.cpp
@@ -46,7 +46,7 @@ int main()
         r = c.equal_range(5);
         assert(std::distance(r.first, r.second) == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.map/equal_range_non_const.pass.cpp b/test/std/containers/unord/unord.map/equal_range_non_const.pass.cpp
index 9e8d1a9644c5..8d7f34a0b1f2 100644
--- a/test/std/containers/unord/unord.map/equal_range_non_const.pass.cpp
+++ b/test/std/containers/unord/unord.map/equal_range_non_const.pass.cpp
@@ -46,7 +46,7 @@ int main()
         r = c.equal_range(5);
         assert(std::distance(r.first, r.second) == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.map/find_const.pass.cpp b/test/std/containers/unord/unord.map/find_const.pass.cpp
index 120efa3061b1..0f0ea68bd720 100644
--- a/test/std/containers/unord/unord.map/find_const.pass.cpp
+++ b/test/std/containers/unord/unord.map/find_const.pass.cpp
@@ -44,7 +44,7 @@ int main()
         i = c.find(5);
         assert(i == c.cend());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.map/find_non_const.pass.cpp b/test/std/containers/unord/unord.map/find_non_const.pass.cpp
index 7582a796dd7c..cbce62daba16 100644
--- a/test/std/containers/unord/unord.map/find_non_const.pass.cpp
+++ b/test/std/containers/unord/unord.map/find_non_const.pass.cpp
@@ -44,7 +44,7 @@ int main()
         i = c.find(5);
         assert(i == c.end());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.map/incomplete_type.pass.cpp b/test/std/containers/unord/unord.map/incomplete_type.pass.cpp
new file mode 100644
index 000000000000..d51b1d8d181f
--- /dev/null
+++ b/test/std/containers/unord/unord.map/incomplete_type.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_map>
+
+// Check that std::unordered_map and it's iterators can be instantiated with an incomplete
+// type.
+
+#include <unordered_map>
+
+template <class Tp>
+struct MyHash {
+  MyHash() {}
+  std::size_t operator()(Tp const&) const {return 42;}
+};
+
+struct A {
+    typedef std::unordered_map<A, A, MyHash<A> > Map;
+    Map m;
+    Map::iterator it;
+    Map::const_iterator cit;
+    Map::local_iterator lit;
+    Map::const_local_iterator clit;
+};
+
+inline bool operator==(A const& L, A const& R) { return &L == &R; }
+
+int main() {
+    A a;
+}
diff --git a/test/std/containers/unord/unord.map/iterators.pass.cpp b/test/std/containers/unord/unord.map/iterators.pass.cpp
index 47b1d7386684..31f4254ea3f8 100644
--- a/test/std/containers/unord/unord.map/iterators.pass.cpp
+++ b/test/std/containers/unord/unord.map/iterators.pass.cpp
@@ -66,7 +66,7 @@ int main()
         assert(std::distance(c.cbegin(), c.cend()) == c.size());
         C::const_iterator i;
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
@@ -116,7 +116,7 @@ int main()
         C::const_iterator cii{};
         assert ( ii1 == ii2 );
         assert ( ii1 == ii4 );
-        
+
         assert (!(ii1 != ii2 ));
 
         assert ( (ii1 == cii ));
diff --git a/test/std/containers/unord/unord.map/local_iterators.pass.cpp b/test/std/containers/unord/unord.map/local_iterators.pass.cpp
index 770b1ace7a3e..33a428a4f654 100644
--- a/test/std/containers/unord/unord.map/local_iterators.pass.cpp
+++ b/test/std/containers/unord/unord.map/local_iterators.pass.cpp
@@ -220,7 +220,7 @@ int main()
         assert(i->first == 4);
         assert(i->second == "four");
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.map/max_load_factor.pass.cpp b/test/std/containers/unord/unord.map/max_load_factor.pass.cpp
index b19a6e6cfa08..d9e1d057af03 100644
--- a/test/std/containers/unord/unord.map/max_load_factor.pass.cpp
+++ b/test/std/containers/unord/unord.map/max_load_factor.pass.cpp
@@ -16,6 +16,11 @@
 // float max_load_factor() const;
 // void max_load_factor(float mlf);
 
+
+#ifdef _LIBCPP_DEBUG
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+#endif
+
 #include <unordered_map>
 #include <string>
 #include <cassert>
diff --git a/test/std/containers/unord/unord.map/max_size.pass.cpp b/test/std/containers/unord/unord.map/max_size.pass.cpp
index 7d5ae3a8e46d..9c1ca18c3054 100644
--- a/test/std/containers/unord/unord.map/max_size.pass.cpp
+++ b/test/std/containers/unord/unord.map/max_size.pass.cpp
@@ -26,7 +26,7 @@ int main()
         std::unordered_map<int, int> u;
         assert(u.max_size() > 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::unordered_map<int, int, std::hash<int>, std::equal_to<int>,
                                     min_allocator<std::pair<const int, int>>> u;
diff --git a/test/std/containers/unord/unord.map/rehash.pass.cpp b/test/std/containers/unord/unord.map/rehash.pass.cpp
index e1a882c69ffd..fce751593a5e 100644
--- a/test/std/containers/unord/unord.map/rehash.pass.cpp
+++ b/test/std/containers/unord/unord.map/rehash.pass.cpp
@@ -68,7 +68,7 @@ int main()
         assert(c.bucket_count() == 31);
         test(c);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.map/reserve.pass.cpp b/test/std/containers/unord/unord.map/reserve.pass.cpp
index bef237f960af..5999801a3923 100644
--- a/test/std/containers/unord/unord.map/reserve.pass.cpp
+++ b/test/std/containers/unord/unord.map/reserve.pass.cpp
@@ -74,7 +74,7 @@ int main()
         assert(c.bucket_count() >= 16);
         test(c);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.map/types.pass.cpp b/test/std/containers/unord/unord.map/types.pass.cpp
index b53ff8e1540a..ecdc53c542cd 100644
--- a/test/std/containers/unord/unord.map/types.pass.cpp
+++ b/test/std/containers/unord/unord.map/types.pass.cpp
@@ -50,7 +50,7 @@ int main()
         static_assert((std::is_same<C::size_type, std::size_t>::value), "");
         static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<char, short, std::hash<char>, std::equal_to<char>,
                             min_allocator<std::pair<const char, short>>> C;
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp
index 0fc76db0fb2f..3c3ec058ead7 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp
@@ -45,7 +45,7 @@ int main()
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
@@ -72,7 +72,7 @@ int main()
         typedef test_hash<std::hash<T>> HF;
         typedef test_compare<std::equal_to<T>> Comp;
         typedef std::unordered_map<T, T, HF, Comp, A> C;
-        
+
         A a(10);
         C c(2, a);
         assert(c.bucket_count() == 2);
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp
index fa0105604f15..ee85750f5c36 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp
@@ -135,7 +135,7 @@ int main()
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef min_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_map<int, std::string,
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/assign_init.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/assign_init.pass.cpp
index 3a854e106543..e4da30bb4efd 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/assign_init.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/assign_init.pass.cpp
@@ -59,7 +59,7 @@ int main()
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef min_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_map<int, std::string,
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/assign_move.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/assign_move.pass.cpp
index dd57c58214fa..fe3eaee4642b 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/assign_move.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/assign_move.pass.cpp
@@ -165,7 +165,7 @@ int main()
         assert(c.max_load_factor() == 1);
         assert(c0.size() == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef min_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_map<int, std::string,
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/compare_copy_constructible.fail.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/compare_copy_constructible.fail.cpp
new file mode 100644
index 000000000000..417120b9eb0e
--- /dev/null
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/compare_copy_constructible.fail.cpp
@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+// The test requires access control SFINAE.
+
+// <unordered_map>
+
+// Check that std::unordered_map fails to instantiate if the comparison predicate is 
+// not copy-constructible. This is LWG issue 2436
+
+#include <unordered_map>
+
+template <class T>
+struct Comp {
+	bool operator () (const T& lhs, const T& rhs) const { return lhs == rhs; }
+
+	Comp () {}
+private:
+	Comp (const Comp &); // declared but not defined
+	};
+
+
+int main() {
+	std::unordered_map<int, int, std::hash<int>, Comp<int> > m;
+}
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp
index 447bcab12e6a..0590d12818b3 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp
@@ -108,7 +108,7 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp
index 7e9125381cab..cb60807cc0e7 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp
@@ -67,7 +67,7 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp
index a0825db1ecd2..537343a59f7c 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp
@@ -45,7 +45,7 @@ int main()
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/default_noexcept.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/default_noexcept.pass.cpp
index 30e0dc1705a3..939e0bcd4e69 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/default_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/default_noexcept.pass.cpp
@@ -17,9 +17,12 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <unordered_map>
 #include <cassert>
 
+#include "test_macros.h"
 #include "MoveOnly.h"
 #include "test_allocator.h"
 #include "../../../test_hash.h"
@@ -30,6 +33,7 @@ struct some_comp
     typedef T value_type;
     some_comp();
     some_comp(const some_comp&);
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 template <class T>
@@ -42,15 +46,14 @@ struct some_hash
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::unordered_map<MoveOnly, MoveOnly> C;
-        static_assert(std::is_nothrow_default_constructible<C>::value, "");
+        LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
     }
     {
         typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>,
                            std::equal_to<MoveOnly>, test_allocator<std::pair<const MoveOnly, MoveOnly>>> C;
-        static_assert(std::is_nothrow_default_constructible<C>::value, "");
+        LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
     }
     {
         typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>,
@@ -66,5 +69,4 @@ int main()
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/dtor_noexcept.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/dtor_noexcept.pass.cpp
index 7fb4200605cf..3585fe7b881a 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/dtor_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/dtor_noexcept.pass.cpp
@@ -11,19 +11,20 @@
 
 // ~unordered_map() // implied noexcept;
 
+// UNSUPPORTED: c++98, c++03
+
 #include <unordered_map>
 #include <cassert>
 
 #include "MoveOnly.h"
 #include "test_allocator.h"
 
-#if __has_feature(cxx_noexcept)
-
 template <class T>
 struct some_comp
 {
     typedef T value_type;
     ~some_comp() noexcept(false);
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 template <class T>
@@ -35,11 +36,8 @@ struct some_hash
     ~some_hash() noexcept(false);
 };
 
-#endif
-
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::unordered_map<MoveOnly, MoveOnly> C;
         static_assert(std::is_nothrow_destructible<C>::value, "");
@@ -63,5 +61,4 @@ int main()
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/hash_copy_constructible.fail.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/hash_copy_constructible.fail.cpp
new file mode 100644
index 000000000000..709b56de2453
--- /dev/null
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/hash_copy_constructible.fail.cpp
@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+// The test requires access control SFINAE.
+
+// <unordered_map>
+
+// Check that std::unordered_map fails to instantiate if the hash function is 
+// not copy-constructible. This is mentioned in LWG issue 2436
+
+#include <unordered_map>
+
+template <class T>
+struct Hash {
+	std::size_t operator () (const T& lhs) const { return 0; }
+
+	Hash () {}
+private:
+	Hash (const Hash &); // declared but not defined
+};
+
+
+int main() {
+	std::unordered_map<int, int, Hash<int> > m;
+}
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/init.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/init.pass.cpp
index dbc48f816c8b..e980b68b57c1 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/init.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/init.pass.cpp
@@ -59,7 +59,7 @@ int main()
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/init_size.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/init_size.pass.cpp
index b60fb2cad90c..07e77e33504f 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/init_size.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/init_size.pass.cpp
@@ -62,7 +62,7 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash.pass.cpp
index f3c086f78876..01aca134a604 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash.pass.cpp
@@ -63,7 +63,7 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal.pass.cpp
index f71c48a70136..08efdbd3591f 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal.pass.cpp
@@ -65,7 +65,7 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal_allocator.pass.cpp
index c02831676715..02cf5e12eb01 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal_allocator.pass.cpp
@@ -66,7 +66,7 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp
index 72a634f0a93d..ea204373890d 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp
@@ -111,7 +111,7 @@ int main()
 
         assert(c0.empty());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::pair<int, std::string> P;
         typedef min_allocator<std::pair<const int, std::string>> A;
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/move_assign_noexcept.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/move_assign_noexcept.pass.cpp
index fc3fc6f05f8a..61c2969d9337 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/move_assign_noexcept.pass.cpp
@@ -17,6 +17,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <unordered_map>
 #include <cassert>
 
@@ -28,6 +30,7 @@ struct some_comp
 {
     typedef T value_type;
     some_comp& operator=(const some_comp&);
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 template <class T>
@@ -41,7 +44,6 @@ struct some_hash
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::unordered_map<MoveOnly, MoveOnly> C;
         static_assert(std::is_nothrow_move_assignable<C>::value, "");
@@ -65,5 +67,4 @@ int main()
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/move_noexcept.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/move_noexcept.pass.cpp
index f292011cd7b6..16dc3dc6d4fa 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/move_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/move_noexcept.pass.cpp
@@ -15,6 +15,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <unordered_map>
 #include <cassert>
 
@@ -26,6 +28,7 @@ struct some_comp
 {
     typedef T value_type;
     some_comp(const some_comp&);
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 template <class T>
@@ -38,7 +41,6 @@ struct some_hash
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::unordered_map<MoveOnly, MoveOnly> C;
         static_assert(std::is_nothrow_move_constructible<C>::value, "");
@@ -62,5 +64,4 @@ int main()
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp
index c1784d63b293..d2a18fa45f11 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp
@@ -63,7 +63,7 @@ int main()
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp
index b63c47a57dfa..9af18ab61f41 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp
@@ -66,7 +66,7 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp
index 675949e9d9be..e23208dba991 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp
@@ -68,7 +68,7 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp
index d55359f7aa06..d296bab32741 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp
@@ -69,7 +69,7 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp
index 61f9f21ad25b..638efcfebb77 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp
@@ -71,7 +71,7 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/size.fail.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/size.fail.cpp
index 0a3ae3a117f1..d2551861ec89 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/size.fail.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/size.fail.cpp
@@ -45,7 +45,7 @@ int main()
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp
index 708dc2362739..465dea21bce1 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp
@@ -45,7 +45,7 @@ int main()
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp
index 6c975ec72030..f70ad7a1e5bc 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp
@@ -47,7 +47,7 @@ int main()
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp
index 8b2bb317987e..184d77d69d5f 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp
@@ -48,7 +48,7 @@ int main()
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp
index bcf7b91503ad..56eb59ddba9b 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp
@@ -49,7 +49,7 @@ int main()
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
diff --git a/test/std/containers/unord/unord.map/unord.map.elem/at.pass.cpp b/test/std/containers/unord/unord.map/unord.map.elem/at.pass.cpp
index 04ce91f69917..5504d33f299b 100644
--- a/test/std/containers/unord/unord.map/unord.map.elem/at.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.elem/at.pass.cpp
@@ -77,7 +77,7 @@ int main()
         }
         assert(c.size() == 4);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.map/unord.map.elem/index.pass.cpp b/test/std/containers/unord/unord.map/unord.map.elem/index.pass.cpp
index c072248f866a..7bc59447a5e6 100644
--- a/test/std/containers/unord/unord.map/unord.map.elem/index.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.elem/index.pass.cpp
@@ -14,13 +14,20 @@
 // class unordered_map
 
 // mapped_type& operator[](const key_type& k);
+// mapped_type& operator[](key_type&& k);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "MoveOnly.h"
 #include "min_allocator.h"
+#include "count_new.hpp"
+
+#if TEST_STD_VER >= 11
+#include "container_test_types.h"
+#endif
 
 int main()
 {
@@ -44,7 +51,7 @@ int main()
         assert(c.size() == 5);
         assert(c.at(11) == "eleven");
     }
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<MoveOnly, std::string> C;
         typedef std::pair<int, std::string> P;
@@ -65,8 +72,6 @@ int main()
         assert(c.size() == 5);
         assert(c.at(11) == "eleven");
     }
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#if __cplusplus >= 201103L
     {
         typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
@@ -88,7 +93,7 @@ int main()
         assert(c.size() == 5);
         assert(c.at(11) == "eleven");
     }
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+
     {
         typedef std::unordered_map<MoveOnly, std::string, std::hash<MoveOnly>, std::equal_to<MoveOnly>,
                             min_allocator<std::pair<const MoveOnly, std::string>>> C;
@@ -110,6 +115,50 @@ int main()
         assert(c.size() == 5);
         assert(c.at(11) == "eleven");
     }
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    {
+        using Container = TCT::unordered_map<>;
+        using Key = Container::key_type;
+        using MappedType = Container::mapped_type;
+        using ValueTp = Container::value_type;
+        ConstructController* cc = getConstructController();
+        cc->reset();
+        {
+            Container c;
+            const Key k(1);
+            cc->expect<std::piecewise_construct_t const&, std::tuple<Key const&>&&, std::tuple<>&&>();
+            MappedType& mref = c[k];
+            assert(!cc->unchecked());
+            {
+                DisableAllocationGuard g;
+                MappedType& mref2 = c[k];
+                assert(&mref == &mref2);
+            }
+        }
+        {
+            Container c;
+            Key k(1);
+            cc->expect<std::piecewise_construct_t const&, std::tuple<Key const&>&&, std::tuple<>&&>();
+            MappedType& mref = c[k];
+            assert(!cc->unchecked());
+            {
+                DisableAllocationGuard g;
+                MappedType& mref2 = c[k];
+                assert(&mref == &mref2);
+            }
+        }
+        {
+            Container c;
+            Key k(1);
+            cc->expect<std::piecewise_construct_t const&, std::tuple<Key &&>&&, std::tuple<>&&>();
+            MappedType& mref = c[std::move(k)];
+            assert(!cc->unchecked());
+            {
+                Key k2(1);
+                DisableAllocationGuard g;
+                MappedType& mref2 = c[std::move(k2)];
+                assert(&mref == &mref2);
+            }
+        }
+    }
 #endif
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.elem/index_tuple.pass.cpp b/test/std/containers/unord/unord.map/unord.map.elem/index_tuple.pass.cpp
index c319b5c30b2c..f2c694e86f74 100644
--- a/test/std/containers/unord/unord.map/unord.map.elem/index_tuple.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.elem/index_tuple.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <unordered_map>
 
 // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
@@ -18,9 +20,6 @@
 // http://llvm.org/bugs/show_bug.cgi?id=16542
 
 #include <unordered_map>
-
-#ifndef _LIBCPP_HAS_NO_VARIADICS
-
 #include <tuple>
 
 using namespace std;
@@ -30,12 +29,8 @@ struct my_hash
     size_t operator()(const tuple<int,int>&) const {return 0;}
 };
 
-#endif
-
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_VARIADICS
     unordered_map<tuple<int,int>, size_t, my_hash> m;
     m[make_tuple(2,3)]=7;
-#endif
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/clear.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/clear.pass.cpp
index 9f320e949479..106423ebfbe9 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/clear.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/clear.pass.cpp
@@ -39,7 +39,7 @@ int main()
         c.clear();
         assert(c.size() == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/emplace.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/emplace.pass.cpp
index 5de74d2e6c92..26f716166464 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/emplace.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/emplace.pass.cpp
@@ -49,7 +49,7 @@ int main()
         assert(r.first->first == 5);
         assert(r.first->second == Emplaceable(6, 7));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, Emplaceable, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, Emplaceable>>> C;
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/emplace_hint.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/emplace_hint.pass.cpp
index 21a4689658ae..477f2cf02e76 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/emplace_hint.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/emplace_hint.pass.cpp
@@ -51,7 +51,7 @@ int main()
         assert(r->first == 5);
         assert(r->second == Emplaceable(6, 7));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, Emplaceable, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, Emplaceable>>> C;
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_range.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_range.pass.cpp
index f0664c3c3ffc..820b12a9bf8b 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_range.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_range.pass.cpp
@@ -58,7 +58,7 @@ int main()
         assert(c.size() == 0);
         assert(k == c.end());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_and_emplace_allocator_requirements.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_and_emplace_allocator_requirements.pass.cpp
new file mode 100644
index 000000000000..00c47182c925
--- /dev/null
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_and_emplace_allocator_requirements.pass.cpp
@@ -0,0 +1,31 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_map>
+
+// class unordered_map
+
+// insert(...);
+// emplace(...);
+
+// UNSUPPORTED: c++98, c++03
+
+
+#include <unordered_map>
+
+#include "container_test_types.h"
+#include "../../../map_allocator_requirement_test_templates.h"
+
+int main()
+{
+  testMapInsert<TCT::unordered_map<> >();
+  testMapInsertHint<TCT::unordered_map<> >();
+  testMapEmplace<TCT::unordered_map<> >();
+  testMapEmplaceHint<TCT::unordered_map<> >();
+}
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_const_lvalue.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_const_lvalue.pass.cpp
index a16f097b4c01..fe2b24707fb3 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_const_lvalue.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_const_lvalue.pass.cpp
@@ -18,69 +18,64 @@
 #include <unordered_map>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+
+template <class Container>
+void do_insert_cv_test()
 {
-    {
-        typedef std::unordered_map<double, int> C;
-        typedef std::pair<C::iterator, bool> R;
-        typedef C::value_type P;
-        C c;
-        R r = c.insert(P(3.5, 3));
-        assert(r.second);
-        assert(c.size() == 1);
-        assert(r.first->first == 3.5);
-        assert(r.first->second == 3);
+    typedef Container M;
+    typedef std::pair<typename M::iterator, bool> R;
+    typedef typename M::value_type VT;
+    M m;
 
-        r = c.insert(P(3.5, 4));
-        assert(!r.second);
-        assert(c.size() == 1);
-        assert(r.first->first == 3.5);
-        assert(r.first->second == 3);
+    const VT v1(2.5, 2);
+    R r = m.insert(v1);
+    assert(r.second);
+    assert(m.size() == 1);
+    assert(r.first->first == 2.5);
+    assert(r.first->second == 2);
 
-        r = c.insert(P(4.5, 4));
-        assert(r.second);
-        assert(c.size() == 2);
-        assert(r.first->first == 4.5);
-        assert(r.first->second == 4);
+    r = m.insert(VT(2.5, 3)); // test rvalue insertion works in C++03
+    assert(!r.second);
+    assert(m.size() == 1);
+    assert(r.first->first == 2.5);
+    assert(r.first->second == 2);
 
-        r = c.insert(P(5.5, 4));
-        assert(r.second);
-        assert(c.size() == 3);
-        assert(r.first->first == 5.5);
-        assert(r.first->second == 4);
-    }
-#if __cplusplus >= 201103L
-    {
-        typedef std::unordered_map<double, int, std::hash<double>, std::equal_to<double>,
-                            min_allocator<std::pair<const double, int>>> C;
-        typedef std::pair<C::iterator, bool> R;
-        typedef C::value_type P;
-        C c;
-        R r = c.insert(P(3.5, 3));
-        assert(r.second);
-        assert(c.size() == 1);
-        assert(r.first->first == 3.5);
-        assert(r.first->second == 3);
+    const VT v2(1.5, 1);
+    r = m.insert(v2);
+    assert(r.second);
+    assert(m.size() == 2);
+    assert(r.first->first == 1.5);
+    assert(r.first->second == 1);
 
-        r = c.insert(P(3.5, 4));
-        assert(!r.second);
-        assert(c.size() == 1);
-        assert(r.first->first == 3.5);
-        assert(r.first->second == 3);
+    const VT v3(3.5, 3);
+    r = m.insert(v3);
+    assert(r.second);
+    assert(m.size() == 3);
+    assert(r.first->first == 3.5);
+    assert(r.first->second == 3);
 
-        r = c.insert(P(4.5, 4));
-        assert(r.second);
-        assert(c.size() == 2);
-        assert(r.first->first == 4.5);
-        assert(r.first->second == 4);
+    const VT v4(3.5, 4);
+    r = m.insert(v4);
+    assert(!r.second);
+    assert(m.size() == 3);
+    assert(r.first->first == 3.5);
+    assert(r.first->second == 3);
+}
 
-        r = c.insert(P(5.5, 4));
-        assert(r.second);
-        assert(c.size() == 3);
-        assert(r.first->first == 5.5);
-        assert(r.first->second == 4);
+int main()
+{
+    {
+        typedef std::unordered_map<double, int> M;
+        do_insert_cv_test<M>();
+    }
+#if TEST_STD_VER >= 11
+    {
+        typedef std::unordered_map<double, int, std::hash<double>, std::equal_to<double>,
+                            min_allocator<std::pair<const double, int>>> M;
+        do_insert_cv_test<M>();
     }
 #endif
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_const_lvalue.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_const_lvalue.pass.cpp
index 981b8fb18a0a..d40a8a61a3d4 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_const_lvalue.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_const_lvalue.pass.cpp
@@ -52,7 +52,7 @@ int main()
         assert(r->first == 5.5);
         assert(r->second == 4);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<double, int, std::hash<double>, std::equal_to<double>,
                             min_allocator<std::pair<const double, int>>> C;
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_rvalue.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_rvalue.pass.cpp
index 1618c1019e1c..04d01eb466e7 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_rvalue.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_rvalue.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <unordered_map>
 
 // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
@@ -55,7 +57,6 @@ int main()
         assert(r->first == 5.5);
         assert(r->second == 4);
     }
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
         typedef std::unordered_map<MoveOnly, MoveOnly> C;
         typedef C::iterator R;
@@ -82,8 +83,6 @@ int main()
         assert(r->first == 5);
         assert(r->second == 4);
     }
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#if __cplusplus >= 201103L
     {
         typedef std::unordered_map<double, int, std::hash<double>, std::equal_to<double>,
                             min_allocator<std::pair<const double, int>>> C;
@@ -111,7 +110,6 @@ int main()
         assert(r->first == 5.5);
         assert(r->second == 4);
     }
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
         typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, std::equal_to<MoveOnly>,
                             min_allocator<std::pair<const MoveOnly, MoveOnly>>> C;
@@ -139,7 +137,31 @@ int main()
         assert(r->first == 5);
         assert(r->second == 4);
     }
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    {
+        typedef std::unordered_map<double, MoveOnly> C;
+        typedef C::iterator R;
+        C c;
+        C::const_iterator e = c.end();
+        R r = c.insert(e, {3.5, 3});
+        assert(c.size() == 1);
+        assert(r->first == 3.5);
+        assert(r->second == 3);
+
+        r = c.insert(c.end(), {3.5, 4});
+        assert(c.size() == 1);
+        assert(r->first == 3.5);
+        assert(r->second == 3);
+
+        r = c.insert(c.end(), {4.5, 4});
+        assert(c.size() == 2);
+        assert(r->first == 4.5);
+        assert(r->second == 4);
+
+        r = c.insert(c.end(), {5.5, 4});
+        assert(c.size() == 3);
+        assert(r->first == 5.5);
+        assert(r->second == 4);
+    }
 #if _LIBCPP_DEBUG >= 1
     {
         typedef std::unordered_map<double, int> C;
@@ -152,5 +174,4 @@ int main()
         assert(false);
     }
 #endif
-#endif
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_init.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_init.pass.cpp
index 81e8a468d83f..a4d8b5d410b4 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_init.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_init.pass.cpp
@@ -45,7 +45,7 @@ int main()
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_range.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_range.pass.cpp
index fc44e7828ffa..b722b4a5ba02 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_range.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_range.pass.cpp
@@ -45,7 +45,7 @@ int main()
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_rvalue.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_rvalue.pass.cpp
index f53dc6c7e97a..faf5b046b5d8 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_rvalue.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_rvalue.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <unordered_map>
 
 // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
@@ -54,7 +56,6 @@ int main()
         assert(r.first->first == 5.5);
         assert(r.first->second == 4);
     }
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
         typedef std::unordered_map<MoveOnly, MoveOnly> C;
         typedef std::pair<C::iterator, bool> R;
@@ -84,8 +85,6 @@ int main()
         assert(r.first->first == 5);
         assert(r.first->second == 4);
     }
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#if __cplusplus >= 201103L
     {
         typedef std::unordered_map<double, int, std::hash<double>, std::equal_to<double>,
                             min_allocator<std::pair<const double, int>>> C;
@@ -116,7 +115,6 @@ int main()
         assert(r.first->first == 5.5);
         assert(r.first->second == 4);
     }
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
         typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, std::equal_to<MoveOnly>,
                             min_allocator<std::pair<const MoveOnly, MoveOnly>>> C;
@@ -147,6 +145,32 @@ int main()
         assert(r.first->first == 5);
         assert(r.first->second == 4);
     }
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#endif
+    {
+        typedef std::unordered_map<double, MoveOnly> C;
+        typedef std::pair<C::iterator, bool> R;
+        C c;
+        R r = c.insert({3.5, 3});
+        assert(r.second);
+        assert(c.size() == 1);
+        assert(r.first->first == 3.5);
+        assert(r.first->second == 3);
+
+        r = c.insert({3.5, 4});
+        assert(!r.second);
+        assert(c.size() == 1);
+        assert(r.first->first == 3.5);
+        assert(r.first->second == 3);
+
+        r = c.insert({4.5, 4});
+        assert(r.second);
+        assert(c.size() == 2);
+        assert(r.first->first == 4.5);
+        assert(r.first->second == 4);
+
+        r = c.insert({5.5, 4});
+        assert(r.second);
+        assert(c.size() == 3);
+        assert(r.first->first == 5.5);
+        assert(r.first->second == 4);
+    }
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/try.emplace.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/try.emplace.pass.cpp
index eabcf2e85db2..adc4d6944ecb 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/try.emplace.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/try.emplace.pass.cpp
@@ -22,7 +22,6 @@
 // template <class... Args>
 //  iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);      // C++17
 
-#include <__config>
 #include <unordered_map>
 #include <cassert>
 #include <tuple>
diff --git a/test/std/containers/unord/unord.map/unord.map.swap/swap_noexcept.pass.cpp b/test/std/containers/unord/unord.map/unord.map.swap/swap_noexcept.pass.cpp
index 1056c231f0db..f8f17ffec57a 100644
--- a/test/std/containers/unord/unord.map/unord.map.swap/swap_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.swap/swap_noexcept.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <unordered_map>
 
 // void swap(unordered_map& c)
@@ -26,6 +28,7 @@
 #include <unordered_map>
 #include <cassert>
 
+#include "test_macros.h"
 #include "MoveOnly.h"
 #include "test_allocator.h"
 
@@ -33,20 +36,20 @@ template <class T>
 struct some_comp
 {
     typedef T value_type;
-    
+
     some_comp() {}
     some_comp(const some_comp&) {}
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 template <class T>
 struct some_comp2
 {
     typedef T value_type;
-    
+
     some_comp2() {}
     some_comp2(const some_comp2&) {}
-    void deallocate(void*, unsigned) {}
-    typedef std::true_type propagate_on_container_swap;
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 #if TEST_STD_VER >= 14
@@ -79,7 +82,7 @@ template <class T>
 struct some_alloc
 {
     typedef T value_type;
-    
+
     some_alloc() {}
     some_alloc(const some_alloc&);
     void deallocate(void*, unsigned) {}
@@ -91,7 +94,7 @@ template <class T>
 struct some_alloc2
 {
     typedef T value_type;
-    
+
     some_alloc2() {}
     some_alloc2(const some_alloc2&);
     void deallocate(void*, unsigned) {}
@@ -104,7 +107,7 @@ template <class T>
 struct some_alloc3
 {
     typedef T value_type;
-    
+
     some_alloc3() {}
     some_alloc3(const some_alloc3&);
     void deallocate(void*, unsigned) {}
@@ -116,7 +119,6 @@ struct some_alloc3
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
 	typedef std::pair<const MoveOnly, MoveOnly> MapType;
     {
         typedef std::unordered_map<MoveOnly, MoveOnly> C;
@@ -195,5 +197,4 @@ int main()
     static_assert( noexcept(swap(c1, c2)), "");
     }
 #endif
-#endif
 }
diff --git a/test/std/containers/unord/unord.multimap/bucket.pass.cpp b/test/std/containers/unord/unord.multimap/bucket.pass.cpp
index be5acc196308..415dce11c128 100644
--- a/test/std/containers/unord/unord.multimap/bucket.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/bucket.pass.cpp
@@ -45,7 +45,7 @@ int main()
         for (size_t i = 0; i < 13; ++i)
             assert(c.bucket(i) == i % bc);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.multimap/bucket_size.pass.cpp b/test/std/containers/unord/unord.multimap/bucket_size.pass.cpp
index a02f72efc6c2..3bc3f5876fe6 100644
--- a/test/std/containers/unord/unord.multimap/bucket_size.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/bucket_size.pass.cpp
@@ -49,7 +49,7 @@ int main()
         assert(c.bucket_size(5) == 0);
         assert(c.bucket_size(6) == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.multimap/count.pass.cpp b/test/std/containers/unord/unord.multimap/count.pass.cpp
index efaf02e3a572..c93a2237c480 100644
--- a/test/std/containers/unord/unord.multimap/count.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/count.pass.cpp
@@ -44,7 +44,7 @@ int main()
         assert(c.count(50) == 3);
         assert(c.count(5) == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.multimap/db_iterators_7.pass.cpp b/test/std/containers/unord/unord.multimap/db_iterators_7.pass.cpp
index b6ba8d6194a4..8a23edd174b0 100644
--- a/test/std/containers/unord/unord.multimap/db_iterators_7.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/db_iterators_7.pass.cpp
@@ -36,7 +36,7 @@ int main()
     ++i;
     assert(false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                         min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.multimap/db_iterators_8.pass.cpp b/test/std/containers/unord/unord.multimap/db_iterators_8.pass.cpp
index f5ea5089349b..e5a9ce961530 100644
--- a/test/std/containers/unord/unord.multimap/db_iterators_8.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/db_iterators_8.pass.cpp
@@ -34,7 +34,7 @@ int main()
     C::value_type j = *i;
     assert(false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                         min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.multimap/db_local_iterators_7.pass.cpp b/test/std/containers/unord/unord.multimap/db_local_iterators_7.pass.cpp
index 93cbd5433f47..2bd161f75072 100644
--- a/test/std/containers/unord/unord.multimap/db_local_iterators_7.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/db_local_iterators_7.pass.cpp
@@ -34,7 +34,7 @@ int main()
     ++i;
     assert(false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                         min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.multimap/db_local_iterators_8.pass.cpp b/test/std/containers/unord/unord.multimap/db_local_iterators_8.pass.cpp
index 159ae4963532..78b40e14e7a1 100644
--- a/test/std/containers/unord/unord.multimap/db_local_iterators_8.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/db_local_iterators_8.pass.cpp
@@ -33,7 +33,7 @@ int main()
     C::value_type j = *i;
     assert(false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                         min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.multimap/eq.pass.cpp b/test/std/containers/unord/unord.multimap/eq.pass.cpp
index 3604e7792c13..f95bea3daef3 100644
--- a/test/std/containers/unord/unord.multimap/eq.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/eq.pass.cpp
@@ -100,7 +100,7 @@ int main()
         assert( (c1 == c2));
         assert(!(c1 != c2));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.multimap/equal_range_const.pass.cpp b/test/std/containers/unord/unord.multimap/equal_range_const.pass.cpp
index 67613b094bfc..382ed7c9831d 100644
--- a/test/std/containers/unord/unord.multimap/equal_range_const.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/equal_range_const.pass.cpp
@@ -57,7 +57,7 @@ int main()
         assert(r.first->first == 50);
         assert(r.first->second == "fiftyB");
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.multimap/equal_range_non_const.pass.cpp b/test/std/containers/unord/unord.multimap/equal_range_non_const.pass.cpp
index eb4c019af951..17eb14e44262 100644
--- a/test/std/containers/unord/unord.multimap/equal_range_non_const.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/equal_range_non_const.pass.cpp
@@ -57,7 +57,7 @@ int main()
         assert(r.first->first == 50);
         assert(r.first->second == "fiftyB");
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.multimap/find_const.pass.cpp b/test/std/containers/unord/unord.multimap/find_const.pass.cpp
index bc2650d111f3..70c2b45efbd4 100644
--- a/test/std/containers/unord/unord.multimap/find_const.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/find_const.pass.cpp
@@ -44,7 +44,7 @@ int main()
         i = c.find(5);
         assert(i == c.cend());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.multimap/find_non_const.pass.cpp b/test/std/containers/unord/unord.multimap/find_non_const.pass.cpp
index 5a128c0f37e1..0510d14419d5 100644
--- a/test/std/containers/unord/unord.multimap/find_non_const.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/find_non_const.pass.cpp
@@ -44,7 +44,7 @@ int main()
         i = c.find(5);
         assert(i == c.end());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.multimap/incomplete.pass.cpp b/test/std/containers/unord/unord.multimap/incomplete.pass.cpp
new file mode 100644
index 000000000000..7822224e7366
--- /dev/null
+++ b/test/std/containers/unord/unord.multimap/incomplete.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_map>
+
+// Check that std::unordered_multimap and it's iterators can be instantiated with an incomplete
+// type.
+
+#include <unordered_map>
+
+template <class Tp>
+struct MyHash {
+  MyHash() {}
+  std::size_t operator()(Tp const&) const {return 42;}
+};
+
+struct A {
+    typedef std::unordered_multimap<A, A, MyHash<A> > Map;
+    Map m;
+    Map::iterator it;
+    Map::const_iterator cit;
+    Map::local_iterator lit;
+    Map::const_local_iterator clit;
+};
+
+inline bool operator==(A const& L, A const& R) { return &L == &R; }
+
+int main() {
+    A a;
+}
diff --git a/test/std/containers/unord/unord.multimap/iterators.pass.cpp b/test/std/containers/unord/unord.multimap/iterators.pass.cpp
index 1831cf1149b1..cc75bb10a811 100644
--- a/test/std/containers/unord/unord.multimap/iterators.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/iterators.pass.cpp
@@ -69,7 +69,7 @@ int main()
         assert(std::distance(c.cbegin(), c.cend()) == c.size());
         C::const_iterator i;
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.multimap/load_factor.pass.cpp b/test/std/containers/unord/unord.multimap/load_factor.pass.cpp
index 52b3f03d88a1..9c42435946ff 100644
--- a/test/std/containers/unord/unord.multimap/load_factor.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/load_factor.pass.cpp
@@ -48,7 +48,7 @@ int main()
         const C c;
         assert(c.load_factor() == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.multimap/local_iterators.pass.cpp b/test/std/containers/unord/unord.multimap/local_iterators.pass.cpp
index 35e4c772fd33..504fe54de830 100644
--- a/test/std/containers/unord/unord.multimap/local_iterators.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/local_iterators.pass.cpp
@@ -284,7 +284,7 @@ int main()
         j = c.cend(b);
         assert(std::distance(i, j) == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.multimap/max_bucket_count.pass.cpp b/test/std/containers/unord/unord.multimap/max_bucket_count.pass.cpp
index 23b90579ec41..a2ab399d3469 100644
--- a/test/std/containers/unord/unord.multimap/max_bucket_count.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/max_bucket_count.pass.cpp
@@ -30,7 +30,7 @@ int main()
         const C c;
         assert(c.max_bucket_count() > 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.multimap/max_load_factor.pass.cpp b/test/std/containers/unord/unord.multimap/max_load_factor.pass.cpp
index 39b7feeba4e5..b0b2b664f098 100644
--- a/test/std/containers/unord/unord.multimap/max_load_factor.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/max_load_factor.pass.cpp
@@ -42,7 +42,7 @@ int main()
         c.max_load_factor(2.5);
         assert(c.max_load_factor() == 2.5);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.multimap/max_size.pass.cpp b/test/std/containers/unord/unord.multimap/max_size.pass.cpp
index caba5932b23c..3bf1f1496f68 100644
--- a/test/std/containers/unord/unord.multimap/max_size.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/max_size.pass.cpp
@@ -26,7 +26,7 @@ int main()
         std::unordered_multimap<int, int> u;
         assert(u.max_size() > 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::unordered_multimap<int, int, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, int>>> u;
diff --git a/test/std/containers/unord/unord.multimap/rehash.pass.cpp b/test/std/containers/unord/unord.multimap/rehash.pass.cpp
index 5ef21d3bc4ce..c099abe2ac05 100644
--- a/test/std/containers/unord/unord.multimap/rehash.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/rehash.pass.cpp
@@ -97,7 +97,7 @@ int main()
         assert(c.bucket_count() == 31);
         test(c);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.multimap/reserve.pass.cpp b/test/std/containers/unord/unord.multimap/reserve.pass.cpp
index 388b1f67e450..3f76da11e3d9 100644
--- a/test/std/containers/unord/unord.multimap/reserve.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/reserve.pass.cpp
@@ -76,7 +76,7 @@ int main()
         assert(c.bucket_count() >= 16);
         test(c);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.multimap/swap_member.pass.cpp b/test/std/containers/unord/unord.multimap/swap_member.pass.cpp
index 225eccd4793f..4653cc32ef36 100644
--- a/test/std/containers/unord/unord.multimap/swap_member.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/swap_member.pass.cpp
@@ -396,7 +396,7 @@ int main()
         assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
diff --git a/test/std/containers/unord/unord.multimap/types.pass.cpp b/test/std/containers/unord/unord.multimap/types.pass.cpp
index 55ae749746c1..e141234904e4 100644
--- a/test/std/containers/unord/unord.multimap/types.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/types.pass.cpp
@@ -50,7 +50,7 @@ int main()
         static_assert((std::is_same<C::size_type, std::size_t>::value), "");
         static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<char, short, std::hash<char>, std::equal_to<char>,
                             min_allocator<std::pair<const char, short>>> C;
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp
index dc41fad29af8..6eb258db4960 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp
@@ -45,7 +45,7 @@ int main()
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
@@ -72,7 +72,7 @@ int main()
         typedef test_hash<std::hash<T>> HF;
         typedef test_compare<std::equal_to<T>> Comp;
         typedef std::unordered_multimap<T, T, HF, Comp, A> C;
-        
+
         A a(10);
         C c(2, a);
         assert(c.bucket_count() == 2);
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp
index df566b396f99..5634a79eff33 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp
@@ -163,7 +163,7 @@ int main()
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef min_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_multimap<int, std::string,
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_init.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_init.pass.cpp
index 2d3c1434d69f..0d3b4453dd44 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_init.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_init.pass.cpp
@@ -84,7 +84,7 @@ int main()
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef min_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_multimap<int, std::string,
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_move.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_move.pass.cpp
index 0c43fa8f06ed..ed8d792e8178 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_move.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_move.pass.cpp
@@ -223,7 +223,7 @@ int main()
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef min_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_multimap<int, std::string,
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/compare_copy_constructible.fail.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/compare_copy_constructible.fail.cpp
new file mode 100644
index 000000000000..d3e31484c8b7
--- /dev/null
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/compare_copy_constructible.fail.cpp
@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+// The test requires access control SFINAE.
+
+// <unordered_map>
+
+// Check that std::unordered_multimap fails to instantiate if the comparison predicate is 
+// not copy-constructible. This is LWG issue 2436
+
+#include <unordered_map>
+
+template <class T>
+struct Comp {
+	bool operator () (const T& lhs, const T& rhs) const { return lhs == rhs; }
+
+	Comp () {}
+private:
+	Comp (const Comp &); // declared but not defined
+	};
+
+
+int main() {
+	std::unordered_multimap<int, int, std::hash<int>, Comp<int> > m;
+}
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp
index 06adfd7cfe05..7b0adda182cb 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp
@@ -136,7 +136,7 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp
index 0fb508f1f124..e759267b45b1 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp
@@ -81,7 +81,7 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp
index 1884065ce0c8..f361b2c3dfdd 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp
@@ -45,7 +45,7 @@ int main()
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default_noexcept.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default_noexcept.pass.cpp
index fac3cec63d70..e404612a754e 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default_noexcept.pass.cpp
@@ -17,9 +17,12 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <unordered_map>
 #include <cassert>
 
+#include "test_macros.h"
 #include "MoveOnly.h"
 #include "test_allocator.h"
 #include "../../../test_hash.h"
@@ -30,6 +33,7 @@ struct some_comp
     typedef T value_type;
     some_comp();
     some_comp(const some_comp&);
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 template <class T>
@@ -42,15 +46,14 @@ struct some_hash
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::unordered_multimap<MoveOnly, MoveOnly> C;
-        static_assert(std::is_nothrow_default_constructible<C>::value, "");
+        LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
     }
     {
         typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>,
                            std::equal_to<MoveOnly>, test_allocator<std::pair<const MoveOnly, MoveOnly>>> C;
-        static_assert(std::is_nothrow_default_constructible<C>::value, "");
+        LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
     }
     {
         typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>,
@@ -66,5 +69,4 @@ int main()
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/dtor_noexcept.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/dtor_noexcept.pass.cpp
index 220785196791..2797f8dcfb04 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/dtor_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/dtor_noexcept.pass.cpp
@@ -11,19 +11,20 @@
 
 // ~unordered_multimap() // implied noexcept;
 
+// UNSUPPORTED: c++98, c++03
+
 #include <unordered_map>
 #include <cassert>
 
 #include "MoveOnly.h"
 #include "test_allocator.h"
 
-#if __has_feature(cxx_noexcept)
-
 template <class T>
 struct some_comp
 {
     typedef T value_type;
     ~some_comp() noexcept(false);
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 template <class T>
@@ -35,11 +36,8 @@ struct some_hash
     ~some_hash() noexcept(false);
 };
 
-#endif
-
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::unordered_multimap<MoveOnly, MoveOnly> C;
         static_assert(std::is_nothrow_destructible<C>::value, "");
@@ -63,5 +61,4 @@ int main()
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/hash_copy_constructible.fail.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/hash_copy_constructible.fail.cpp
new file mode 100644
index 000000000000..4214f694a20f
--- /dev/null
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/hash_copy_constructible.fail.cpp
@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+// The test requires access control SFINAE.
+
+// <unordered_map>
+
+// Check that std::unordered_multimap fails to instantiate if the hash function is 
+// not copy-constructible. This is mentioned in LWG issue 2436
+
+#include <unordered_map>
+
+template <class T>
+struct Hash {
+	std::size_t operator () (const T& lhs) const { return 0; }
+
+	Hash () {}
+private:
+	Hash (const Hash &); // declared but not defined
+	};
+
+
+int main() {
+	std::unordered_multimap<int, int, Hash<int> > m;
+}
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init.pass.cpp
index cc5532adbe08..f6bc3a08cae9 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init.pass.cpp
@@ -81,7 +81,7 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size.pass.cpp
index 8f6710a93317..5dc4323493e4 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size.pass.cpp
@@ -84,7 +84,7 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash.pass.cpp
index 0962e9b29f83..8bcbd0bdc352 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash.pass.cpp
@@ -85,7 +85,7 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal.pass.cpp
index 324b0a7c1a5e..8dda376db3f9 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal.pass.cpp
@@ -87,7 +87,7 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp
index 23ae7d19f9c2..6843613b0481 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp
@@ -88,7 +88,7 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >(10)));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp
index b61735eb0256..58d1424d8b1e 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp
@@ -128,7 +128,7 @@ int main()
 
         assert(c0.empty());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp
index 106c29cda8d0..a66e41e8e35c 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp
@@ -159,7 +159,7 @@ int main()
 
         assert(c0.empty());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::pair<int, std::string> P;
         typedef min_allocator<std::pair<const int, std::string>> A;
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_assign_noexcept.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_assign_noexcept.pass.cpp
index 47e61ab70b83..eeda7b39e958 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_assign_noexcept.pass.cpp
@@ -17,6 +17,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <unordered_map>
 #include <cassert>
 
@@ -28,6 +30,7 @@ struct some_comp
 {
     typedef T value_type;
     some_comp& operator=(const some_comp&);
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 template <class T>
@@ -41,7 +44,6 @@ struct some_hash
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::unordered_multimap<MoveOnly, MoveOnly> C;
         static_assert(std::is_nothrow_move_assignable<C>::value, "");
@@ -65,5 +67,4 @@ int main()
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_noexcept.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_noexcept.pass.cpp
index 37f17876973a..965c46499a16 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_noexcept.pass.cpp
@@ -15,6 +15,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <unordered_map>
 #include <cassert>
 
@@ -26,6 +28,7 @@ struct some_comp
 {
     typedef T value_type;
     some_comp(const some_comp&);
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 template <class T>
@@ -38,7 +41,6 @@ struct some_hash
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::unordered_multimap<MoveOnly, MoveOnly> C;
         static_assert(std::is_nothrow_move_constructible<C>::value, "");
@@ -62,5 +64,4 @@ int main()
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp
index bb700ec565dc..96ad70a56e0f 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp
@@ -85,7 +85,7 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp
index ad33b13054c7..15b31b519b74 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp
@@ -88,7 +88,7 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp
index 98644c75e33b..f565f10c89b5 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp
@@ -90,7 +90,7 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp
index 9a79c3056358..8f86befbe37f 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp
@@ -91,7 +91,7 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp
index a5aafb96c7b0..e8040d88de2a 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp
@@ -93,7 +93,7 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >(10)));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.fail.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.fail.cpp
index 44cf84ff323c..38e6c60df52d 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.fail.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.fail.cpp
@@ -45,7 +45,7 @@ int main()
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.pass.cpp
index bd56a41fd71f..8aad662610ab 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.pass.cpp
@@ -45,7 +45,7 @@ int main()
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash.pass.cpp
index 33460612ce3f..2cc6c0176e5e 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash.pass.cpp
@@ -47,7 +47,7 @@ int main()
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal.pass.cpp
index c2420ce9e6f5..ebfce9fec564 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal.pass.cpp
@@ -48,7 +48,7 @@ int main()
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal_allocator.pass.cpp
index 33886670b3b4..56e3808984c5 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal_allocator.pass.cpp
@@ -49,7 +49,7 @@ int main()
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/clear.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/clear.pass.cpp
index 4efcfaa6ce53..891d44911eb0 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/clear.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/clear.pass.cpp
@@ -39,7 +39,7 @@ int main()
         c.clear();
         assert(c.size() == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/emplace.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/emplace.pass.cpp
index 4f2e8ef061fa..96678cf33fa5 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/emplace.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/emplace.pass.cpp
@@ -46,7 +46,7 @@ int main()
         assert(r->first == 5);
         assert(r->second == Emplaceable(6, 7));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, Emplaceable, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, Emplaceable>>> C;
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/emplace_hint.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/emplace_hint.pass.cpp
index 4d141ad137c8..8bccd4013a29 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/emplace_hint.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/emplace_hint.pass.cpp
@@ -59,7 +59,7 @@ int main()
         assert(r->first == 3);
         assert(r->second == Emplaceable(5, 6));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, Emplaceable, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, Emplaceable>>> C;
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_const_iter.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_const_iter.pass.cpp
index b31a4e56b31e..9da1e71cba06 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_const_iter.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_const_iter.pass.cpp
@@ -76,7 +76,7 @@ int main()
         assert(std::distance(c.begin(), c.end()) == c.size());
         assert(std::distance(c.cbegin(), c.cend()) == c.size());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
@@ -123,7 +123,7 @@ int main()
         assert(std::distance(c.cbegin(), c.cend()) == c.size());
     }
 #endif
-#if __cplusplus >= 201402L
+#if TEST_STD_VER >= 14
     {
     //  This is LWG #2059
         typedef TemplateConstructor T;
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_key.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_key.pass.cpp
index 892f8a247502..f061d858e3f7 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_key.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_key.pass.cpp
@@ -21,12 +21,12 @@
 
 #include "min_allocator.h"
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
 template <typename Unordered>
 bool only_deletions ( const Unordered &whole, const Unordered &part ) {
     typename Unordered::const_iterator w = whole.begin();
     typename Unordered::const_iterator p = part.begin();
-    
+
     while ( w != whole.end () && p != part.end()) {
         if ( *w == *p )
             p++;
@@ -200,7 +200,7 @@ int main()
         assert(std::distance(c.begin(), c.end()) == c.size());
         assert(std::distance(c.cbegin(), c.cend()) == c.size());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
@@ -372,7 +372,7 @@ int main()
             m2.insert(std::make_pair(i,j));
             }
         }
-    
+
     C::iterator i = m2.begin();
     int ctr = 0;
     while (i != m2.end()) {
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_range.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_range.pass.cpp
index f60ec071ff70..110cc4542b42 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_range.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_range.pass.cpp
@@ -98,7 +98,7 @@ int main()
         assert(c.size() == 0);
         assert(k == c.end());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_allocator_requirements.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_allocator_requirements.pass.cpp
new file mode 100644
index 000000000000..30f78936ff92
--- /dev/null
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_allocator_requirements.pass.cpp
@@ -0,0 +1,27 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_map>
+
+// class unordered_multimap
+
+// insert(...)
+
+// UNSUPPORTED: c++98, c++03
+
+#include <unordered_map>
+
+#include "container_test_types.h"
+#include "../../../map_allocator_requirement_test_templates.h"
+
+int main()
+{
+  testMultimapInsert<TCT::unordered_multimap<> >();
+  testMultimapInsertHint<TCT::unordered_multimap<> >();
+}
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_const_lvalue.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_const_lvalue.pass.cpp
index e7e7cb03b6d0..320fbc8fe2ea 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_const_lvalue.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_const_lvalue.pass.cpp
@@ -47,7 +47,7 @@ int main()
         assert(r->first == 5.5);
         assert(r->second == 4);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<double, int, std::hash<double>, std::equal_to<double>,
                             min_allocator<std::pair<const double, int>>> C;
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_const_lvalue.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_const_lvalue.pass.cpp
index c7cb1f4c014b..c920ae93553f 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_const_lvalue.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_const_lvalue.pass.cpp
@@ -52,7 +52,7 @@ int main()
         assert(r->first == 5.5);
         assert(r->second == 4);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<double, int, std::hash<double>, std::equal_to<double>,
                             min_allocator<std::pair<const double, int>>> C;
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_rvalue.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_rvalue.pass.cpp
index 7116fa02b6f5..d6c0dbdbed07 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_rvalue.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_rvalue.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <unordered_map>
 
 // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
@@ -55,7 +57,6 @@ int main()
         assert(r->first == 5.5);
         assert(r->second == 4);
     }
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
         typedef std::unordered_multimap<MoveOnly, MoveOnly> C;
         typedef C::iterator R;
@@ -82,8 +83,6 @@ int main()
         assert(r->first == 5);
         assert(r->second == 4);
     }
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#if __cplusplus >= 201103L
     {
         typedef std::unordered_multimap<double, int, std::hash<double>, std::equal_to<double>,
                             min_allocator<std::pair<const double, int>>> C;
@@ -111,7 +110,6 @@ int main()
         assert(r->first == 5.5);
         assert(r->second == 4);
     }
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
         typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>, std::equal_to<MoveOnly>,
                             min_allocator<std::pair<const MoveOnly, MoveOnly>>> C;
@@ -139,7 +137,31 @@ int main()
         assert(r->first == 5);
         assert(r->second == 4);
     }
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    {
+        typedef std::unordered_multimap<double, int> C;
+        typedef C::iterator R;
+        C c;
+        C::const_iterator e = c.end();
+        R r = c.insert(e, {3.5, 3});
+        assert(c.size() == 1);
+        assert(r->first == 3.5);
+        assert(r->second == 3);
+
+        r = c.insert(r, {3.5, 4});
+        assert(c.size() == 2);
+        assert(r->first == 3.5);
+        assert(r->second == 4);
+
+        r = c.insert(c.end(), {4.5, 4});
+        assert(c.size() == 3);
+        assert(r->first == 4.5);
+        assert(r->second == 4);
+
+        r = c.insert(c.end(), {5.5, 4});
+        assert(c.size() == 4);
+        assert(r->first == 5.5);
+        assert(r->second == 4);
+    }
 #if _LIBCPP_DEBUG >= 1
     {
         typedef std::unordered_multimap<double, int> C;
@@ -152,5 +174,4 @@ int main()
         assert(false);
     }
 #endif
-#endif
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_init.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_init.pass.cpp
index 23dbe84a3c51..851b36e51ca4 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_init.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_init.pass.cpp
@@ -70,7 +70,7 @@ int main()
         assert(std::distance(c.begin(), c.end()) == c.size());
         assert(std::distance(c.cbegin(), c.cend()) == c.size());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp
index 2820639b4ea0..967ad369da3f 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp
@@ -70,7 +70,7 @@ int main()
         assert(std::distance(c.begin(), c.end()) == c.size());
         assert(std::distance(c.cbegin(), c.cend()) == c.size());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_rvalue.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_rvalue.pass.cpp
index 5a98467e9d0f..6735b8af5a0a 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_rvalue.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_rvalue.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <unordered_map>
 
 // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
@@ -50,7 +52,6 @@ int main()
         assert(r->first == 5.5);
         assert(r->second == 4);
     }
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
         typedef std::unordered_multimap<MoveOnly, MoveOnly> C;
         typedef C::iterator R;
@@ -76,8 +77,6 @@ int main()
         assert(r->first == 5);
         assert(r->second == 4);
     }
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#if __cplusplus >= 201103L
     {
         typedef std::unordered_multimap<double, int, std::hash<double>, std::equal_to<double>,
                             min_allocator<std::pair<const double, int>>> C;
@@ -104,7 +103,6 @@ int main()
         assert(r->first == 5.5);
         assert(r->second == 4);
     }
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
         typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>, std::equal_to<MoveOnly>,
                             min_allocator<std::pair<const MoveOnly, MoveOnly>>> C;
@@ -131,6 +129,28 @@ int main()
         assert(r->first == 5);
         assert(r->second == 4);
     }
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#endif
+    {
+        typedef std::unordered_multimap<double, MoveOnly> C;
+        typedef C::iterator R;
+        C c;
+        R r = c.insert({3.5, 3});
+        assert(c.size() == 1);
+        assert(r->first == 3.5);
+        assert(r->second == 3);
+
+        r = c.insert({3.5, 4});
+        assert(c.size() == 2);
+        assert(r->first == 3.5);
+        assert(r->second == 4);
+
+        r = c.insert({4.5, 4});
+        assert(c.size() == 3);
+        assert(r->first == 4.5);
+        assert(r->second == 4);
+
+        r = c.insert({5.5, 4});
+        assert(c.size() == 4);
+        assert(r->first == 5.5);
+        assert(r->second == 4);
+    }
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_noexcept.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_noexcept.pass.cpp
index 7c912e01d572..553131182315 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_noexcept.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <unordered_map>
 
 // void swap(unordered_multimap& c)
@@ -26,6 +28,7 @@
 #include <unordered_map>
 #include <cassert>
 
+#include "test_macros.h"
 #include "MoveOnly.h"
 #include "test_allocator.h"
 
@@ -33,20 +36,20 @@ template <class T>
 struct some_comp
 {
     typedef T value_type;
-    
+
     some_comp() {}
     some_comp(const some_comp&) {}
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 template <class T>
 struct some_comp2
 {
     typedef T value_type;
-    
+
     some_comp2() {}
     some_comp2(const some_comp2&) {}
-    void deallocate(void*, unsigned) {}
-    typedef std::true_type propagate_on_container_swap;
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 #if TEST_STD_VER >= 14
@@ -79,7 +82,7 @@ template <class T>
 struct some_alloc
 {
     typedef T value_type;
-    
+
     some_alloc() {}
     some_alloc(const some_alloc&);
     void deallocate(void*, unsigned) {}
@@ -91,7 +94,7 @@ template <class T>
 struct some_alloc2
 {
     typedef T value_type;
-    
+
     some_alloc2() {}
     some_alloc2(const some_alloc2&);
     void deallocate(void*, unsigned) {}
@@ -104,7 +107,7 @@ template <class T>
 struct some_alloc3
 {
     typedef T value_type;
-    
+
     some_alloc3() {}
     some_alloc3(const some_alloc3&);
     void deallocate(void*, unsigned) {}
@@ -115,7 +118,6 @@ struct some_alloc3
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     typedef std::pair<const MoveOnly, MoveOnly> V;
     {
         typedef std::unordered_multimap<MoveOnly, MoveOnly> C;
@@ -193,6 +195,4 @@ int main()
     static_assert( noexcept(swap(c1, c2)), "");
     }
 #endif
-
-#endif
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp
index 0f579e091683..84911ba01ffb 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp
@@ -395,7 +395,7 @@ int main()
         assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
diff --git a/test/std/containers/unord/unord.multiset/bucket.pass.cpp b/test/std/containers/unord/unord.multiset/bucket.pass.cpp
index 0293133d494a..30858c79a048 100644
--- a/test/std/containers/unord/unord.multiset/bucket.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/bucket.pass.cpp
@@ -44,7 +44,7 @@ int main()
         for (size_t i = 0; i < 13; ++i)
             assert(c.bucket(i) == i % bc);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
diff --git a/test/std/containers/unord/unord.multiset/bucket_count.pass.cpp b/test/std/containers/unord/unord.multiset/bucket_count.pass.cpp
index c7842e5c1977..adde647cb246 100644
--- a/test/std/containers/unord/unord.multiset/bucket_count.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/bucket_count.pass.cpp
@@ -47,7 +47,7 @@ int main()
         const C c(std::begin(a), std::end(a));
         assert(c.bucket_count() >= 11);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
diff --git a/test/std/containers/unord/unord.multiset/bucket_size.pass.cpp b/test/std/containers/unord/unord.multiset/bucket_size.pass.cpp
index 639d7ac37965..7ca480556349 100644
--- a/test/std/containers/unord/unord.multiset/bucket_size.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/bucket_size.pass.cpp
@@ -48,7 +48,7 @@ int main()
         assert(c.bucket_size(5) == 0);
         assert(c.bucket_size(6) == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
diff --git a/test/std/containers/unord/unord.multiset/clear.pass.cpp b/test/std/containers/unord/unord.multiset/clear.pass.cpp
index 61ca847e7c4a..57dbb8b1faaa 100644
--- a/test/std/containers/unord/unord.multiset/clear.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/clear.pass.cpp
@@ -38,7 +38,7 @@ int main()
         c.clear();
         assert(c.size() == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
diff --git a/test/std/containers/unord/unord.multiset/count.pass.cpp b/test/std/containers/unord/unord.multiset/count.pass.cpp
index e548324d9545..9f61845fa69c 100644
--- a/test/std/containers/unord/unord.multiset/count.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/count.pass.cpp
@@ -43,7 +43,7 @@ int main()
         assert(c.count(50) == 3);
         assert(c.count(5) == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
diff --git a/test/std/containers/unord/unord.multiset/db_iterators_7.pass.cpp b/test/std/containers/unord/unord.multiset/db_iterators_7.pass.cpp
index c8ef2fbca163..91f083b241d6 100644
--- a/test/std/containers/unord/unord.multiset/db_iterators_7.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/db_iterators_7.pass.cpp
@@ -35,7 +35,7 @@ int main()
     ++i;
     assert(false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef int T;
     typedef std::unordered_multiset<T, min_allocator<T>> C;
diff --git a/test/std/containers/unord/unord.multiset/db_iterators_8.pass.cpp b/test/std/containers/unord/unord.multiset/db_iterators_8.pass.cpp
index eef799787947..3d78ed4c022f 100644
--- a/test/std/containers/unord/unord.multiset/db_iterators_8.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/db_iterators_8.pass.cpp
@@ -33,7 +33,7 @@ int main()
     T j = *i;
     assert(false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef int T;
     typedef std::unordered_multiset<T, min_allocator<T>> C;
diff --git a/test/std/containers/unord/unord.multiset/db_local_iterators_7.pass.cpp b/test/std/containers/unord/unord.multiset/db_local_iterators_7.pass.cpp
index c1de95cace71..cf8874803cb7 100644
--- a/test/std/containers/unord/unord.multiset/db_local_iterators_7.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/db_local_iterators_7.pass.cpp
@@ -34,7 +34,7 @@ int main()
     ++i;
     assert(false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef int T;
     typedef std::unordered_multiset<T, min_allocator<T>> C;
diff --git a/test/std/containers/unord/unord.multiset/db_local_iterators_8.pass.cpp b/test/std/containers/unord/unord.multiset/db_local_iterators_8.pass.cpp
index 962b85298ae1..46e5ba7d5f84 100644
--- a/test/std/containers/unord/unord.multiset/db_local_iterators_8.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/db_local_iterators_8.pass.cpp
@@ -33,7 +33,7 @@ int main()
     T j = *i;
     assert(false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef int T;
     typedef std::unordered_multiset<T, min_allocator<T>> C;
diff --git a/test/std/containers/unord/unord.multiset/emplace.pass.cpp b/test/std/containers/unord/unord.multiset/emplace.pass.cpp
index 13787d9b4037..d8d9e9bc5695 100644
--- a/test/std/containers/unord/unord.multiset/emplace.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/emplace.pass.cpp
@@ -41,7 +41,7 @@ int main()
         assert(c.size() == 3);
         assert(*r == Emplaceable(5, 6));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<Emplaceable, std::hash<Emplaceable>,
                       std::equal_to<Emplaceable>, min_allocator<Emplaceable>> C;
diff --git a/test/std/containers/unord/unord.multiset/emplace_hint.pass.cpp b/test/std/containers/unord/unord.multiset/emplace_hint.pass.cpp
index 8885cc03cf03..3756476dc8fc 100644
--- a/test/std/containers/unord/unord.multiset/emplace_hint.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/emplace_hint.pass.cpp
@@ -46,7 +46,7 @@ int main()
         assert(c.size() == 3);
         assert(*r == Emplaceable(5, 6));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<Emplaceable, std::hash<Emplaceable>,
                       std::equal_to<Emplaceable>, min_allocator<Emplaceable>> C;
diff --git a/test/std/containers/unord/unord.multiset/eq.pass.cpp b/test/std/containers/unord/unord.multiset/eq.pass.cpp
index bbedbc905a4b..9c59d0cf5e9f 100644
--- a/test/std/containers/unord/unord.multiset/eq.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/eq.pass.cpp
@@ -99,7 +99,7 @@ int main()
         assert( (c1 == c2));
         assert(!(c1 != c2));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
diff --git a/test/std/containers/unord/unord.multiset/equal_range_const.pass.cpp b/test/std/containers/unord/unord.multiset/equal_range_const.pass.cpp
index a0aaac2bd868..e89410e61633 100644
--- a/test/std/containers/unord/unord.multiset/equal_range_const.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/equal_range_const.pass.cpp
@@ -53,7 +53,7 @@ int main()
         ++r.first;
         assert(*r.first == 50);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
diff --git a/test/std/containers/unord/unord.multiset/equal_range_non_const.pass.cpp b/test/std/containers/unord/unord.multiset/equal_range_non_const.pass.cpp
index 73d44f7a56b7..a9373cec6517 100644
--- a/test/std/containers/unord/unord.multiset/equal_range_non_const.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/equal_range_non_const.pass.cpp
@@ -53,7 +53,7 @@ int main()
         ++r.first;
         assert(*r.first == 50);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
diff --git a/test/std/containers/unord/unord.multiset/erase_const_iter.pass.cpp b/test/std/containers/unord/unord.multiset/erase_const_iter.pass.cpp
index d3be2b6d6365..117e8e68efab 100644
--- a/test/std/containers/unord/unord.multiset/erase_const_iter.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/erase_const_iter.pass.cpp
@@ -52,7 +52,7 @@ int main()
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
@@ -76,7 +76,7 @@ int main()
         assert(c.count(4) == 1);
     }
 #endif
-#if __cplusplus >= 201402L
+#if TEST_STD_VER >= 14
     {
     //  This is LWG #2059
         typedef TemplateConstructor T;
diff --git a/test/std/containers/unord/unord.multiset/erase_key.pass.cpp b/test/std/containers/unord/unord.multiset/erase_key.pass.cpp
index 7c243973f163..e8ff71d0316b 100644
--- a/test/std/containers/unord/unord.multiset/erase_key.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/erase_key.pass.cpp
@@ -21,12 +21,12 @@
 
 #include "min_allocator.h"
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
 template <typename Unordered>
 bool only_deletions ( const Unordered &whole, const Unordered &part ) {
     typename Unordered::const_iterator w = whole.begin();
     typename Unordered::const_iterator p = part.begin();
-    
+
     while ( w != whole.end () && p != part.end()) {
         if ( *w == *p )
             p++;
@@ -95,7 +95,7 @@ int main()
         assert(c.erase(3) == 0);
         assert(c.size() == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
@@ -160,7 +160,7 @@ int main()
         m.insert(i);  m.insert(i);
         m2.insert(i); m2.insert(i);
         }
-    
+
     C::iterator i = m2.begin();
     int ctr = 0;
     while (i != m2.end()) {
diff --git a/test/std/containers/unord/unord.multiset/erase_range.pass.cpp b/test/std/containers/unord/unord.multiset/erase_range.pass.cpp
index baac08eddc1e..a4f703df8506 100644
--- a/test/std/containers/unord/unord.multiset/erase_range.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/erase_range.pass.cpp
@@ -55,7 +55,7 @@ int main()
         assert(c.size() == 0);
         assert(k == c.end());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
diff --git a/test/std/containers/unord/unord.multiset/find_const.pass.cpp b/test/std/containers/unord/unord.multiset/find_const.pass.cpp
index 5caaf207aaf2..505266b1f022 100644
--- a/test/std/containers/unord/unord.multiset/find_const.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/find_const.pass.cpp
@@ -42,7 +42,7 @@ int main()
         i = c.find(5);
         assert(i == c.cend());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
diff --git a/test/std/containers/unord/unord.multiset/find_non_const.pass.cpp b/test/std/containers/unord/unord.multiset/find_non_const.pass.cpp
index 030487863f98..32ee79aa7554 100644
--- a/test/std/containers/unord/unord.multiset/find_non_const.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/find_non_const.pass.cpp
@@ -42,7 +42,7 @@ int main()
         i = c.find(5);
         assert(i == c.cend());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
diff --git a/test/std/containers/unord/unord.multiset/incomplete.pass.cpp b/test/std/containers/unord/unord.multiset/incomplete.pass.cpp
new file mode 100644
index 000000000000..f6d8dc17c5a2
--- /dev/null
+++ b/test/std/containers/unord/unord.multiset/incomplete.pass.cpp
@@ -0,0 +1,38 @@
+
+
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_set>
+
+// Check that std::unordered_multiset and it's iterators can be instantiated with an incomplete
+// type.
+
+#include <unordered_set>
+
+template <class Tp>
+struct MyHash {
+  MyHash() {}
+  std::size_t operator()(Tp const&) const {return 42;}
+};
+
+struct A {
+    typedef std::unordered_multiset<A, MyHash<A> > Map;
+    Map m;
+    Map::iterator it;
+    Map::const_iterator cit;
+    Map::local_iterator lit;
+    Map::const_local_iterator clit;
+};
+
+inline bool operator==(A const& L, A const& R) { return &L == &R; }
+
+int main() {
+    A a;
+}
diff --git a/test/std/containers/unord/unord.multiset/insert_allocator_requirements.pass.cpp b/test/std/containers/unord/unord.multiset/insert_allocator_requirements.pass.cpp
new file mode 100644
index 000000000000..ad7bc043a5b3
--- /dev/null
+++ b/test/std/containers/unord/unord.multiset/insert_allocator_requirements.pass.cpp
@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_set>
+
+// class unordered_multiset
+
+// insert(...)
+
+// UNSUPPORTED: c++98, c++03
+
+#include <unordered_set>
+#include "container_test_types.h"
+#include "../../set_allocator_requirement_test_templates.h"
+
+int main()
+{
+  testMultisetInsert<TCT::unordered_multiset<> >();
+}
diff --git a/test/std/containers/unord/unord.multiset/insert_const_lvalue.pass.cpp b/test/std/containers/unord/unord.multiset/insert_const_lvalue.pass.cpp
index 0051e497fd7a..946858ea53dc 100644
--- a/test/std/containers/unord/unord.multiset/insert_const_lvalue.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/insert_const_lvalue.pass.cpp
@@ -43,7 +43,7 @@ int main()
         assert(c.size() == 4);
         assert(*r == 5.5);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<double, std::hash<double>,
                                 std::equal_to<double>, min_allocator<double>> C;
diff --git a/test/std/containers/unord/unord.multiset/insert_hint_const_lvalue.pass.cpp b/test/std/containers/unord/unord.multiset/insert_hint_const_lvalue.pass.cpp
index 25b4bc1aa04a..a6ab26659b55 100644
--- a/test/std/containers/unord/unord.multiset/insert_hint_const_lvalue.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/insert_hint_const_lvalue.pass.cpp
@@ -48,7 +48,7 @@ int main()
         assert(c.size() == 4);
         assert(*r == 5.5);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<double, std::hash<double>,
                                 std::equal_to<double>, min_allocator<double>> C;
diff --git a/test/std/containers/unord/unord.multiset/insert_hint_rvalue.pass.cpp b/test/std/containers/unord/unord.multiset/insert_hint_rvalue.pass.cpp
index 481ec80231c9..f5026e102c42 100644
--- a/test/std/containers/unord/unord.multiset/insert_hint_rvalue.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/insert_hint_rvalue.pass.cpp
@@ -73,7 +73,7 @@ int main()
         assert(*r == 5);
     }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<double, std::hash<double>,
                                 std::equal_to<double>, min_allocator<double>> C;
diff --git a/test/std/containers/unord/unord.multiset/insert_init.pass.cpp b/test/std/containers/unord/unord.multiset/insert_init.pass.cpp
index 6941d86f6197..9010cac99caf 100644
--- a/test/std/containers/unord/unord.multiset/insert_init.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/insert_init.pass.cpp
@@ -44,7 +44,7 @@ int main()
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
diff --git a/test/std/containers/unord/unord.multiset/insert_range.pass.cpp b/test/std/containers/unord/unord.multiset/insert_range.pass.cpp
index 41c9d8136feb..3d36ff9d4ce1 100644
--- a/test/std/containers/unord/unord.multiset/insert_range.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/insert_range.pass.cpp
@@ -44,7 +44,7 @@ int main()
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
diff --git a/test/std/containers/unord/unord.multiset/insert_rvalue.pass.cpp b/test/std/containers/unord/unord.multiset/insert_rvalue.pass.cpp
index 2718324b4d08..04f9e34164ab 100644
--- a/test/std/containers/unord/unord.multiset/insert_rvalue.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/insert_rvalue.pass.cpp
@@ -67,7 +67,7 @@ int main()
         assert(*r == 5);
     }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<double, std::hash<double>,
                                 std::equal_to<double>, min_allocator<double>> C;
diff --git a/test/std/containers/unord/unord.multiset/iterators.pass.cpp b/test/std/containers/unord/unord.multiset/iterators.pass.cpp
index be95b44517fe..bf42740c23fb 100644
--- a/test/std/containers/unord/unord.multiset/iterators.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/iterators.pass.cpp
@@ -65,7 +65,7 @@ int main()
         assert(std::distance(c.cbegin(), c.cend()) == c.size());
         C::const_iterator i;
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
diff --git a/test/std/containers/unord/unord.multiset/load_factor.pass.cpp b/test/std/containers/unord/unord.multiset/load_factor.pass.cpp
index 2a5724b3d270..fad1c182e6b7 100644
--- a/test/std/containers/unord/unord.multiset/load_factor.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/load_factor.pass.cpp
@@ -47,7 +47,7 @@ int main()
         const C c;
         assert(c.load_factor() == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
diff --git a/test/std/containers/unord/unord.multiset/local_iterators.pass.cpp b/test/std/containers/unord/unord.multiset/local_iterators.pass.cpp
index 3471707e42a1..8ba9f0f9579d 100644
--- a/test/std/containers/unord/unord.multiset/local_iterators.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/local_iterators.pass.cpp
@@ -259,7 +259,7 @@ int main()
         j = c.cend(b);
         assert(std::distance(i, j) == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
diff --git a/test/std/containers/unord/unord.multiset/max_bucket_count.pass.cpp b/test/std/containers/unord/unord.multiset/max_bucket_count.pass.cpp
index 619a8cf1266f..510ba5fe4da0 100644
--- a/test/std/containers/unord/unord.multiset/max_bucket_count.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/max_bucket_count.pass.cpp
@@ -27,7 +27,7 @@ int main()
         const C c;
         assert(c.max_bucket_count() > 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
diff --git a/test/std/containers/unord/unord.multiset/max_load_factor.pass.cpp b/test/std/containers/unord/unord.multiset/max_load_factor.pass.cpp
index 08f52bb70840..00fe962327f8 100644
--- a/test/std/containers/unord/unord.multiset/max_load_factor.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/max_load_factor.pass.cpp
@@ -41,7 +41,7 @@ int main()
         c.max_load_factor(2.5);
         assert(c.max_load_factor() == 2.5);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
diff --git a/test/std/containers/unord/unord.multiset/max_size.pass.cpp b/test/std/containers/unord/unord.multiset/max_size.pass.cpp
index a5d0b5538bce..b26ad73fed2b 100644
--- a/test/std/containers/unord/unord.multiset/max_size.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/max_size.pass.cpp
@@ -26,7 +26,7 @@ int main()
         std::unordered_multiset<int> u;
         assert(u.max_size() > 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> u;
diff --git a/test/std/containers/unord/unord.multiset/rehash.pass.cpp b/test/std/containers/unord/unord.multiset/rehash.pass.cpp
index 5c7c6aa8aad3..3ad16a6bcbfe 100644
--- a/test/std/containers/unord/unord.multiset/rehash.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/rehash.pass.cpp
@@ -67,7 +67,7 @@ int main()
         assert(c.bucket_count() == 31);
         test(c);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
diff --git a/test/std/containers/unord/unord.multiset/reserve.pass.cpp b/test/std/containers/unord/unord.multiset/reserve.pass.cpp
index 1d393a09cde2..52d51011fe36 100644
--- a/test/std/containers/unord/unord.multiset/reserve.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/reserve.pass.cpp
@@ -73,7 +73,7 @@ int main()
         assert(c.bucket_count() >= 16);
         test(c);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
diff --git a/test/std/containers/unord/unord.multiset/swap_member.pass.cpp b/test/std/containers/unord/unord.multiset/swap_member.pass.cpp
index 275ff4094e81..bc3314c867eb 100644
--- a/test/std/containers/unord/unord.multiset/swap_member.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/swap_member.pass.cpp
@@ -386,7 +386,7 @@ int main()
         assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
diff --git a/test/std/containers/unord/unord.multiset/types.pass.cpp b/test/std/containers/unord/unord.multiset/types.pass.cpp
index 5222222d8197..ee5c2c38ac0c 100644
--- a/test/std/containers/unord/unord.multiset/types.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/types.pass.cpp
@@ -48,7 +48,7 @@ int main()
         static_assert((std::is_same<C::size_type, std::size_t>::value), "");
         static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<short, std::hash<short>,
                                   std::equal_to<short>, min_allocator<short>> C;
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/allocator.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/allocator.pass.cpp
index ccd21a58b22c..8d020a52ac04 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/allocator.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/allocator.pass.cpp
@@ -43,7 +43,7 @@ int main()
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp
index 2042f69fd772..f219073cffcb 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp
@@ -151,7 +151,7 @@ int main()
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef min_allocator<int> A;
         typedef std::unordered_multiset<int,
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_init.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_init.pass.cpp
index 4eaf2c5779f3..2835cd444c30 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_init.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_init.pass.cpp
@@ -59,7 +59,7 @@ int main()
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef min_allocator<int> A;
         typedef std::unordered_multiset<int,
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_move.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_move.pass.cpp
index 4b0e52c5930c..52d08f3e2293 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_move.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_move.pass.cpp
@@ -170,7 +170,7 @@ int main()
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef test_allocator<int> A;
         typedef std::unordered_multiset<int,
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/compare_copy_constructible.fail.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/compare_copy_constructible.fail.cpp
new file mode 100644
index 000000000000..b38316c37689
--- /dev/null
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/compare_copy_constructible.fail.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_set>
+
+// Check that std::unordered_set fails to instantiate if the comparison predicate is 
+// not copy-constructible. This is LWG issue 2436
+
+#include <unordered_set>
+
+template <class T>
+struct Comp {
+	bool operator () (const T& lhs, const T& rhs) const { return lhs == rhs; }
+
+	Comp () {}
+private:
+	Comp (const Comp &); // declared but not defined
+	};
+
+
+int main() {
+	std::unordered_multiset<int, std::hash<int>, Comp<int> > m;
+}
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp
index a91ee1dae071..e6042b0d9123 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp
@@ -121,7 +121,7 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp
index 32c876d32878..5e24f7257252 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp
@@ -73,7 +73,7 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default.pass.cpp
index 737ae2dae793..e741f3208dac 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default.pass.cpp
@@ -43,7 +43,7 @@ int main()
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default_noexcept.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default_noexcept.pass.cpp
index 391609fd144a..fba024aed00e 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default_noexcept.pass.cpp
@@ -17,9 +17,12 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <unordered_set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "MoveOnly.h"
 #include "test_allocator.h"
 #include "../../../test_hash.h"
@@ -30,6 +33,7 @@ struct some_comp
     typedef T value_type;
     some_comp();
     some_comp(const some_comp&);
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 template <class T>
@@ -42,15 +46,14 @@ struct some_hash
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::unordered_multiset<MoveOnly> C;
-        static_assert(std::is_nothrow_default_constructible<C>::value, "");
+        LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
     }
     {
         typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>,
                            std::equal_to<MoveOnly>, test_allocator<MoveOnly>> C;
-        static_assert(std::is_nothrow_default_constructible<C>::value, "");
+        LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
     }
     {
         typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>,
@@ -66,5 +69,4 @@ int main()
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/dtor_noexcept.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/dtor_noexcept.pass.cpp
index a549288afc14..733484510ef1 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/dtor_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/dtor_noexcept.pass.cpp
@@ -11,19 +11,20 @@
 
 // ~unordered_multiset() // implied noexcept;
 
+// UNSUPPORTED: c++98, c++03
+
 #include <unordered_set>
 #include <cassert>
 
 #include "MoveOnly.h"
 #include "test_allocator.h"
 
-#if __has_feature(cxx_noexcept)
-
 template <class T>
 struct some_comp
 {
     typedef T value_type;
     ~some_comp() noexcept(false);
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 template <class T>
@@ -35,11 +36,8 @@ struct some_hash
     ~some_hash() noexcept(false);
 };
 
-#endif
-
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::unordered_multiset<MoveOnly> C;
         static_assert(std::is_nothrow_destructible<C>::value, "");
@@ -63,5 +61,4 @@ int main()
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/hash_copy_constructible.fail.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/hash_copy_constructible.fail.cpp
new file mode 100644
index 000000000000..a43f94ca2af3
--- /dev/null
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/hash_copy_constructible.fail.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_set>
+
+// Check that std::unordered_multiset fails to instantiate if the hash function is 
+// not copy-constructible. This is mentioned in LWG issue 2436
+
+#include <unordered_set>
+
+template <class T>
+struct Hash {
+	std::size_t operator () (const T& lhs) const { return 0; }
+
+	Hash () {}
+private:
+	Hash (const Hash &); // declared but not defined
+	};
+
+
+int main() {
+	std::unordered_multiset<int, Hash<int> > m;
+}
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init.pass.cpp
index 416c28cf83db..53a9003b0173 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init.pass.cpp
@@ -57,7 +57,7 @@ int main()
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size.pass.cpp
index ad42d76db9ee..e5934acc8e7c 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size.pass.cpp
@@ -60,7 +60,7 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash.pass.cpp
index 7cc50fa30067..86253214af9c 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash.pass.cpp
@@ -62,7 +62,7 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal.pass.cpp
index 18d3c8288cd2..47469c0c5b9b 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal.pass.cpp
@@ -63,7 +63,7 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal_allocator.pass.cpp
index 92d9d86040bb..d72ee6f33f50 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal_allocator.pass.cpp
@@ -64,7 +64,7 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move.pass.cpp
index 687f2654f86c..defd90f408b0 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move.pass.cpp
@@ -103,7 +103,7 @@ int main()
 
         assert(c0.empty());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_alloc.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_alloc.pass.cpp
index c03c605f40ce..45b4c8b4f5d5 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_alloc.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_alloc.pass.cpp
@@ -118,7 +118,7 @@ int main()
 
         assert(c0.empty());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int P;
         typedef min_allocator<int> A;
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_assign_noexcept.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_assign_noexcept.pass.cpp
index 2f86f018d9fe..fbd6df14c052 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_assign_noexcept.pass.cpp
@@ -17,6 +17,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <unordered_set>
 #include <cassert>
 
@@ -28,6 +30,7 @@ struct some_comp
 {
     typedef T value_type;
     some_comp& operator=(const some_comp&);
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 template <class T>
@@ -41,7 +44,6 @@ struct some_hash
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::unordered_multiset<MoveOnly> C;
         static_assert(std::is_nothrow_move_assignable<C>::value, "");
@@ -65,5 +67,4 @@ int main()
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_noexcept.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_noexcept.pass.cpp
index 8a4c3c945364..e84ffb7b2fde 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_noexcept.pass.cpp
@@ -15,6 +15,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <unordered_set>
 #include <cassert>
 
@@ -26,6 +28,7 @@ struct some_comp
 {
     typedef T value_type;
     some_comp(const some_comp&);
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 template <class T>
@@ -38,7 +41,6 @@ struct some_hash
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::unordered_multiset<MoveOnly> C;
         static_assert(std::is_nothrow_move_constructible<C>::value, "");
@@ -62,5 +64,4 @@ int main()
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp
index cd2bb1e7bbcd..12679ef3e13e 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp
@@ -60,7 +60,7 @@ int main()
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp
index f2d0db932bd7..c9454cf630db 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp
@@ -63,7 +63,7 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp
index dc40b361d1f3..5ff61575d994 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp
@@ -65,7 +65,7 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp
index c316b7809d53..ecf3176e90a4 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp
@@ -66,7 +66,7 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp
index ab76248c326c..18a092c83f6a 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp
@@ -68,7 +68,7 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.fail.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.fail.cpp
index e55db7ca2aaf..215b31fef65f 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.fail.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.fail.cpp
@@ -43,7 +43,7 @@ int main()
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.pass.cpp
index 35bfbe331b41..38211f958c43 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.pass.cpp
@@ -43,7 +43,7 @@ int main()
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash.pass.cpp
index 0171ea64ebb1..baeabd1b2d08 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash.pass.cpp
@@ -45,7 +45,7 @@ int main()
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal.pass.cpp
index 785cdf246368..380f36df7bf2 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal.pass.cpp
@@ -46,7 +46,7 @@ int main()
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal_allocator.pass.cpp
index 50dd3c95ee52..149d045e07a9 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal_allocator.pass.cpp
@@ -47,7 +47,7 @@ int main()
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_noexcept.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_noexcept.pass.cpp
index 63642fcd7cca..df9f18b147e3 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_noexcept.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <unordered_set>
 
 // void swap(unordered_multiset& c)
@@ -26,6 +28,7 @@
 #include <unordered_set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "MoveOnly.h"
 #include "test_allocator.h"
 
@@ -33,20 +36,20 @@ template <class T>
 struct some_comp
 {
     typedef T value_type;
-    
+
     some_comp() {}
     some_comp(const some_comp&) {}
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 template <class T>
 struct some_comp2
 {
     typedef T value_type;
-    
+
     some_comp2() {}
     some_comp2(const some_comp2&) {}
-    void deallocate(void*, unsigned) {}
-    typedef std::true_type propagate_on_container_swap;
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 #if TEST_STD_VER >= 14
@@ -60,6 +63,7 @@ struct some_hash
     typedef T value_type;
     some_hash() {}
     some_hash(const some_hash&);
+    std::size_t operator()(const T&) const { return 0; }
 };
 
 template <class T>
@@ -68,6 +72,7 @@ struct some_hash2
     typedef T value_type;
     some_hash2() {}
     some_hash2(const some_hash2&);
+    std::size_t operator()(const T&) const { return 0; }
 };
 
 #if TEST_STD_VER >= 14
@@ -79,7 +84,7 @@ template <class T>
 struct some_alloc
 {
     typedef T value_type;
-    
+
     some_alloc() {}
     some_alloc(const some_alloc&);
     void deallocate(void*, unsigned) {}
@@ -91,7 +96,7 @@ template <class T>
 struct some_alloc2
 {
     typedef T value_type;
-    
+
     some_alloc2() {}
     some_alloc2(const some_alloc2&);
     void deallocate(void*, unsigned) {}
@@ -104,7 +109,7 @@ template <class T>
 struct some_alloc3
 {
     typedef T value_type;
-    
+
     some_alloc3() {}
     some_alloc3(const some_alloc3&);
     void deallocate(void*, unsigned) {}
@@ -115,7 +120,6 @@ struct some_alloc3
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::unordered_multiset<MoveOnly> C;
         C c1, c2;
@@ -193,6 +197,4 @@ int main()
     static_assert( noexcept(swap(c1, c2)), "");
     }
 #endif
-
-#endif
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp
index 624b81c5eb3e..4b1c129508e1 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp
@@ -386,7 +386,7 @@ int main()
         assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
diff --git a/test/std/containers/unord/unord.set/bucket.pass.cpp b/test/std/containers/unord/unord.set/bucket.pass.cpp
index 0dae664e0b23..9b704ccee0c0 100644
--- a/test/std/containers/unord/unord.set/bucket.pass.cpp
+++ b/test/std/containers/unord/unord.set/bucket.pass.cpp
@@ -44,7 +44,7 @@ int main()
         for (size_t i = 0; i < 13; ++i)
             assert(c.bucket(i) == i % bc);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
         typedef int P;
diff --git a/test/std/containers/unord/unord.set/bucket_count.pass.cpp b/test/std/containers/unord/unord.set/bucket_count.pass.cpp
index caaa5a6011a9..e35e43615dd3 100644
--- a/test/std/containers/unord/unord.set/bucket_count.pass.cpp
+++ b/test/std/containers/unord/unord.set/bucket_count.pass.cpp
@@ -47,7 +47,7 @@ int main()
         const C c(std::begin(a), std::end(a));
         assert(c.bucket_count() >= 11);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
         typedef C::const_iterator I;
diff --git a/test/std/containers/unord/unord.set/bucket_size.pass.cpp b/test/std/containers/unord/unord.set/bucket_size.pass.cpp
index 628d55737a82..2ae618c85e5b 100644
--- a/test/std/containers/unord/unord.set/bucket_size.pass.cpp
+++ b/test/std/containers/unord/unord.set/bucket_size.pass.cpp
@@ -46,7 +46,7 @@ int main()
         assert(c.bucket_size(3) == 1);
         assert(c.bucket_size(4) == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
         typedef int P;
diff --git a/test/std/containers/unord/unord.set/clear.pass.cpp b/test/std/containers/unord/unord.set/clear.pass.cpp
index 6da15308508c..8ebf748eb8da 100644
--- a/test/std/containers/unord/unord.set/clear.pass.cpp
+++ b/test/std/containers/unord/unord.set/clear.pass.cpp
@@ -38,7 +38,7 @@ int main()
         c.clear();
         assert(c.size() == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
         typedef int P;
diff --git a/test/std/containers/unord/unord.set/count.pass.cpp b/test/std/containers/unord/unord.set/count.pass.cpp
index 83bb8aaa2be0..18cac7cf9b0d 100644
--- a/test/std/containers/unord/unord.set/count.pass.cpp
+++ b/test/std/containers/unord/unord.set/count.pass.cpp
@@ -43,7 +43,7 @@ int main()
         assert(c.count(50) == 1);
         assert(c.count(5) == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
         typedef int P;
diff --git a/test/std/containers/unord/unord.set/db_iterators_7.pass.cpp b/test/std/containers/unord/unord.set/db_iterators_7.pass.cpp
index 80b1a49c5758..647e30b8089c 100644
--- a/test/std/containers/unord/unord.set/db_iterators_7.pass.cpp
+++ b/test/std/containers/unord/unord.set/db_iterators_7.pass.cpp
@@ -35,7 +35,7 @@ int main()
     ++i;
     assert(false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef int T;
     typedef std::unordered_set<T, min_allocator<T>> C;
diff --git a/test/std/containers/unord/unord.set/db_iterators_8.pass.cpp b/test/std/containers/unord/unord.set/db_iterators_8.pass.cpp
index 8b266bbf664f..4c303194c20e 100644
--- a/test/std/containers/unord/unord.set/db_iterators_8.pass.cpp
+++ b/test/std/containers/unord/unord.set/db_iterators_8.pass.cpp
@@ -33,7 +33,7 @@ int main()
     T j = *i;
     assert(false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef int T;
     typedef std::unordered_set<T, min_allocator<T>> C;
diff --git a/test/std/containers/unord/unord.set/db_local_iterators_7.pass.cpp b/test/std/containers/unord/unord.set/db_local_iterators_7.pass.cpp
index b9fcb8c4ae0c..9dbd43d2f7a8 100644
--- a/test/std/containers/unord/unord.set/db_local_iterators_7.pass.cpp
+++ b/test/std/containers/unord/unord.set/db_local_iterators_7.pass.cpp
@@ -34,7 +34,7 @@ int main()
     ++i;
     assert(false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef int T;
     typedef std::unordered_set<T, min_allocator<T>> C;
diff --git a/test/std/containers/unord/unord.set/db_local_iterators_8.pass.cpp b/test/std/containers/unord/unord.set/db_local_iterators_8.pass.cpp
index 74d131b19abe..1212321fe1d1 100644
--- a/test/std/containers/unord/unord.set/db_local_iterators_8.pass.cpp
+++ b/test/std/containers/unord/unord.set/db_local_iterators_8.pass.cpp
@@ -33,7 +33,7 @@ int main()
     T j = *i;
     assert(false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef int T;
     typedef std::unordered_set<T, min_allocator<T>> C;
diff --git a/test/std/containers/unord/unord.set/emplace.pass.cpp b/test/std/containers/unord/unord.set/emplace.pass.cpp
index d105e7ac0f4e..19af8065819c 100644
--- a/test/std/containers/unord/unord.set/emplace.pass.cpp
+++ b/test/std/containers/unord/unord.set/emplace.pass.cpp
@@ -44,7 +44,7 @@ int main()
         assert(*r.first == Emplaceable(5, 6));
         assert(!r.second);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<Emplaceable, std::hash<Emplaceable>,
                       std::equal_to<Emplaceable>, min_allocator<Emplaceable>> C;
diff --git a/test/std/containers/unord/unord.set/emplace_hint.pass.cpp b/test/std/containers/unord/unord.set/emplace_hint.pass.cpp
index 50b0035165d2..97f3591d012b 100644
--- a/test/std/containers/unord/unord.set/emplace_hint.pass.cpp
+++ b/test/std/containers/unord/unord.set/emplace_hint.pass.cpp
@@ -46,7 +46,7 @@ int main()
         assert(c.size() == 2);
         assert(*r == Emplaceable(5, 6));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<Emplaceable, std::hash<Emplaceable>,
                       std::equal_to<Emplaceable>, min_allocator<Emplaceable>> C;
diff --git a/test/std/containers/unord/unord.set/eq.pass.cpp b/test/std/containers/unord/unord.set/eq.pass.cpp
index 54a9c2eced34..8ff4ac5df37f 100644
--- a/test/std/containers/unord/unord.set/eq.pass.cpp
+++ b/test/std/containers/unord/unord.set/eq.pass.cpp
@@ -90,7 +90,7 @@ int main()
         assert( (c1 == c2));
         assert(!(c1 != c2));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
         typedef int P;
diff --git a/test/std/containers/unord/unord.set/equal_range_const.pass.cpp b/test/std/containers/unord/unord.set/equal_range_const.pass.cpp
index 4168903e0200..9fa4129c330a 100644
--- a/test/std/containers/unord/unord.set/equal_range_const.pass.cpp
+++ b/test/std/containers/unord/unord.set/equal_range_const.pass.cpp
@@ -49,7 +49,7 @@ int main()
         assert(std::distance(r.first, r.second) == 1);
         assert(*r.first == 50);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
         typedef C::const_iterator I;
diff --git a/test/std/containers/unord/unord.set/equal_range_non_const.pass.cpp b/test/std/containers/unord/unord.set/equal_range_non_const.pass.cpp
index 5a55083ba8ab..c6a42aceaaf2 100644
--- a/test/std/containers/unord/unord.set/equal_range_non_const.pass.cpp
+++ b/test/std/containers/unord/unord.set/equal_range_non_const.pass.cpp
@@ -49,7 +49,7 @@ int main()
         assert(std::distance(r.first, r.second) == 1);
         assert(*r.first == 50);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
         typedef C::iterator I;
diff --git a/test/std/containers/unord/unord.set/erase_const_iter.pass.cpp b/test/std/containers/unord/unord.set/erase_const_iter.pass.cpp
index 4110953badb6..c78eb138fd90 100644
--- a/test/std/containers/unord/unord.set/erase_const_iter.pass.cpp
+++ b/test/std/containers/unord/unord.set/erase_const_iter.pass.cpp
@@ -51,7 +51,7 @@ int main()
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
         typedef int P;
@@ -73,7 +73,7 @@ int main()
         assert(c.count(4) == 1);
     }
 #endif
-#if __cplusplus >= 201402L
+#if TEST_STD_VER >= 14
     {
     //  This is LWG #2059
         typedef TemplateConstructor T;
diff --git a/test/std/containers/unord/unord.set/erase_key.pass.cpp b/test/std/containers/unord/unord.set/erase_key.pass.cpp
index ca165083b023..ea0323ba2dac 100644
--- a/test/std/containers/unord/unord.set/erase_key.pass.cpp
+++ b/test/std/containers/unord/unord.set/erase_key.pass.cpp
@@ -21,12 +21,12 @@
 
 #include "min_allocator.h"
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
 template <typename Unordered>
 bool only_deletions ( const Unordered &whole, const Unordered &part ) {
     typename Unordered::const_iterator w = whole.begin();
     typename Unordered::const_iterator p = part.begin();
-    
+
     while ( w != whole.end () && p != part.end()) {
         if ( *w == *p )
             p++;
@@ -95,7 +95,7 @@ int main()
         assert(c.erase(3) == 0);
         assert(c.size() == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
         typedef int P;
@@ -159,7 +159,7 @@ int main()
         m.insert(i);
         m2.insert(i);
         }
-    
+
     C::iterator i = m2.begin();
     int ctr = 0;
     while (i != m2.end()) {
diff --git a/test/std/containers/unord/unord.set/erase_range.pass.cpp b/test/std/containers/unord/unord.set/erase_range.pass.cpp
index a8a900551c7b..4e49a86ef836 100644
--- a/test/std/containers/unord/unord.set/erase_range.pass.cpp
+++ b/test/std/containers/unord/unord.set/erase_range.pass.cpp
@@ -55,7 +55,7 @@ int main()
         assert(c.size() == 0);
         assert(k == c.end());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
         typedef int P;
diff --git a/test/std/containers/unord/unord.set/find_const.pass.cpp b/test/std/containers/unord/unord.set/find_const.pass.cpp
index e2238e5665f9..bd4542c876bf 100644
--- a/test/std/containers/unord/unord.set/find_const.pass.cpp
+++ b/test/std/containers/unord/unord.set/find_const.pass.cpp
@@ -42,7 +42,7 @@ int main()
         i = c.find(5);
         assert(i == c.cend());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
         typedef int P;
diff --git a/test/std/containers/unord/unord.set/find_non_const.pass.cpp b/test/std/containers/unord/unord.set/find_non_const.pass.cpp
index 8afe32abd72f..4c81fc60a393 100644
--- a/test/std/containers/unord/unord.set/find_non_const.pass.cpp
+++ b/test/std/containers/unord/unord.set/find_non_const.pass.cpp
@@ -42,7 +42,7 @@ int main()
         i = c.find(5);
         assert(i == c.cend());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
         typedef int P;
diff --git a/test/std/containers/unord/unord.set/incomplete.pass.cpp b/test/std/containers/unord/unord.set/incomplete.pass.cpp
new file mode 100644
index 000000000000..c970c1de5531
--- /dev/null
+++ b/test/std/containers/unord/unord.set/incomplete.pass.cpp
@@ -0,0 +1,38 @@
+
+
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_set>
+
+// Check that std::unordered_set and it's iterators can be instantiated with an incomplete
+// type.
+
+#include <unordered_set>
+
+template <class Tp>
+struct MyHash {
+  MyHash() {}
+  std::size_t operator()(Tp const&) const {return 42;}
+};
+
+struct A {
+    typedef std::unordered_set<A, MyHash<A> > Map;
+    Map m;
+    Map::iterator it;
+    Map::const_iterator cit;
+    Map::local_iterator lit;
+    Map::const_local_iterator clit;
+};
+
+inline bool operator==(A const& L, A const& R) { return &L == &R; }
+
+int main() {
+    A a;
+}
diff --git a/test/std/containers/unord/unord.set/insert_and_emplace_allocator_requirements.pass.cpp b/test/std/containers/unord/unord.set/insert_and_emplace_allocator_requirements.pass.cpp
new file mode 100644
index 000000000000..e85e94538e74
--- /dev/null
+++ b/test/std/containers/unord/unord.set/insert_and_emplace_allocator_requirements.pass.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_set>
+
+// class unordered_set
+
+// insert(...)
+// emplace(...)
+
+// UNSUPPORTED: c++98, c++03
+
+#include <unordered_set>
+
+#include "container_test_types.h"
+#include "../../set_allocator_requirement_test_templates.h"
+
+
+int main()
+{
+  testSetInsert<TCT::unordered_set<> >();
+  testSetEmplace<TCT::unordered_set<> >();
+}
diff --git a/test/std/containers/unord/unord.set/insert_const_lvalue.pass.cpp b/test/std/containers/unord/unord.set/insert_const_lvalue.pass.cpp
index 321e9054af6c..fe45b98a33a6 100644
--- a/test/std/containers/unord/unord.set/insert_const_lvalue.pass.cpp
+++ b/test/std/containers/unord/unord.set/insert_const_lvalue.pass.cpp
@@ -47,7 +47,7 @@ int main()
         assert(*r.first == 5.5);
         assert(r.second);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<double, std::hash<double>,
                                 std::equal_to<double>, min_allocator<double>> C;
diff --git a/test/std/containers/unord/unord.set/insert_hint_const_lvalue.pass.cpp b/test/std/containers/unord/unord.set/insert_hint_const_lvalue.pass.cpp
index 1393f5420111..d3bbecc95ad7 100644
--- a/test/std/containers/unord/unord.set/insert_hint_const_lvalue.pass.cpp
+++ b/test/std/containers/unord/unord.set/insert_hint_const_lvalue.pass.cpp
@@ -48,7 +48,7 @@ int main()
         assert(c.size() == 3);
         assert(*r == 5.5);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<double, std::hash<double>,
                                 std::equal_to<double>, min_allocator<double>> C;
diff --git a/test/std/containers/unord/unord.set/insert_hint_rvalue.pass.cpp b/test/std/containers/unord/unord.set/insert_hint_rvalue.pass.cpp
index 3f04dbb89984..da94bc55382f 100644
--- a/test/std/containers/unord/unord.set/insert_hint_rvalue.pass.cpp
+++ b/test/std/containers/unord/unord.set/insert_hint_rvalue.pass.cpp
@@ -73,7 +73,7 @@ int main()
         assert(*r == 5);
     }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<double, std::hash<double>,
                                 std::equal_to<double>, min_allocator<double>> C;
diff --git a/test/std/containers/unord/unord.set/insert_init.pass.cpp b/test/std/containers/unord/unord.set/insert_init.pass.cpp
index 2d8eafba4891..27b7290eb341 100644
--- a/test/std/containers/unord/unord.set/insert_init.pass.cpp
+++ b/test/std/containers/unord/unord.set/insert_init.pass.cpp
@@ -44,7 +44,7 @@ int main()
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
diff --git a/test/std/containers/unord/unord.set/insert_range.pass.cpp b/test/std/containers/unord/unord.set/insert_range.pass.cpp
index 72a83abf74e9..41b2c0e1431b 100644
--- a/test/std/containers/unord/unord.set/insert_range.pass.cpp
+++ b/test/std/containers/unord/unord.set/insert_range.pass.cpp
@@ -44,7 +44,7 @@ int main()
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
diff --git a/test/std/containers/unord/unord.set/insert_rvalue.pass.cpp b/test/std/containers/unord/unord.set/insert_rvalue.pass.cpp
index e043579bf971..5d12f225cc6a 100644
--- a/test/std/containers/unord/unord.set/insert_rvalue.pass.cpp
+++ b/test/std/containers/unord/unord.set/insert_rvalue.pass.cpp
@@ -75,7 +75,7 @@ int main()
         assert(r.second);
     }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<double, std::hash<double>,
                                 std::equal_to<double>, min_allocator<double>> C;
diff --git a/test/std/containers/unord/unord.set/iterators.pass.cpp b/test/std/containers/unord/unord.set/iterators.pass.cpp
index d3a45801f162..494411854977 100644
--- a/test/std/containers/unord/unord.set/iterators.pass.cpp
+++ b/test/std/containers/unord/unord.set/iterators.pass.cpp
@@ -65,7 +65,7 @@ int main()
         assert(std::distance(c.cbegin(), c.cend()) == c.size());
         C::const_iterator i;
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
diff --git a/test/std/containers/unord/unord.set/load_factor.pass.cpp b/test/std/containers/unord/unord.set/load_factor.pass.cpp
index 3e56442d384c..a342d472a3d5 100644
--- a/test/std/containers/unord/unord.set/load_factor.pass.cpp
+++ b/test/std/containers/unord/unord.set/load_factor.pass.cpp
@@ -47,7 +47,7 @@ int main()
         const C c;
         assert(c.load_factor() == 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
diff --git a/test/std/containers/unord/unord.set/local_iterators.pass.cpp b/test/std/containers/unord/unord.set/local_iterators.pass.cpp
index 2ffd93f30d19..55c80e4cb185 100644
--- a/test/std/containers/unord/unord.set/local_iterators.pass.cpp
+++ b/test/std/containers/unord/unord.set/local_iterators.pass.cpp
@@ -203,7 +203,7 @@ int main()
         assert(std::distance(i, j) == 1);
         assert(*i == 4);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
diff --git a/test/std/containers/unord/unord.set/max_bucket_count.pass.cpp b/test/std/containers/unord/unord.set/max_bucket_count.pass.cpp
index 8b5e265de3f2..dab13ea5ae5f 100644
--- a/test/std/containers/unord/unord.set/max_bucket_count.pass.cpp
+++ b/test/std/containers/unord/unord.set/max_bucket_count.pass.cpp
@@ -27,7 +27,7 @@ int main()
         const C c;
         assert(c.max_bucket_count() > 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
diff --git a/test/std/containers/unord/unord.set/max_load_factor.pass.cpp b/test/std/containers/unord/unord.set/max_load_factor.pass.cpp
index d326f4a2d7e2..542788cca967 100644
--- a/test/std/containers/unord/unord.set/max_load_factor.pass.cpp
+++ b/test/std/containers/unord/unord.set/max_load_factor.pass.cpp
@@ -41,7 +41,7 @@ int main()
         c.max_load_factor(2.5);
         assert(c.max_load_factor() == 2.5);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
diff --git a/test/std/containers/unord/unord.set/max_size.pass.cpp b/test/std/containers/unord/unord.set/max_size.pass.cpp
index 1c6e74125c7d..3135ad994737 100644
--- a/test/std/containers/unord/unord.set/max_size.pass.cpp
+++ b/test/std/containers/unord/unord.set/max_size.pass.cpp
@@ -26,7 +26,7 @@ int main()
         std::unordered_set<int> u;
         assert(u.max_size() > 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         std::unordered_set<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> u;
diff --git a/test/std/containers/unord/unord.set/rehash.pass.cpp b/test/std/containers/unord/unord.set/rehash.pass.cpp
index e28c25dc8197..a4d4d3fbf02c 100644
--- a/test/std/containers/unord/unord.set/rehash.pass.cpp
+++ b/test/std/containers/unord/unord.set/rehash.pass.cpp
@@ -67,7 +67,7 @@ int main()
         assert(c.bucket_count() == 31);
         test(c);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
diff --git a/test/std/containers/unord/unord.set/reserve.pass.cpp b/test/std/containers/unord/unord.set/reserve.pass.cpp
index 078b886b267e..4bd5332f0796 100644
--- a/test/std/containers/unord/unord.set/reserve.pass.cpp
+++ b/test/std/containers/unord/unord.set/reserve.pass.cpp
@@ -73,7 +73,7 @@ int main()
         assert(c.bucket_count() >= 16);
         test(c);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
diff --git a/test/std/containers/unord/unord.set/swap_member.pass.cpp b/test/std/containers/unord/unord.set/swap_member.pass.cpp
index 89ec986d08f3..5ddb2d00daef 100644
--- a/test/std/containers/unord/unord.set/swap_member.pass.cpp
+++ b/test/std/containers/unord/unord.set/swap_member.pass.cpp
@@ -386,7 +386,7 @@ int main()
         assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
diff --git a/test/std/containers/unord/unord.set/types.pass.cpp b/test/std/containers/unord/unord.set/types.pass.cpp
index 7e752a434ece..fdda2b8072e3 100644
--- a/test/std/containers/unord/unord.set/types.pass.cpp
+++ b/test/std/containers/unord/unord.set/types.pass.cpp
@@ -48,7 +48,7 @@ int main()
         static_assert((std::is_same<C::size_type, std::size_t>::value), "");
         static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<short, std::hash<short>,
                                   std::equal_to<short>, min_allocator<short>> C;
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/allocator.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/allocator.pass.cpp
index 30905aeb9fe2..d0b03b2cd0b8 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/allocator.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/allocator.pass.cpp
@@ -43,7 +43,7 @@ int main()
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp
index 6925e3045412..05cb0525eb79 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp
@@ -134,7 +134,7 @@ int main()
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef min_allocator<int> A;
         typedef std::unordered_set<int,
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/assign_init.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/assign_init.pass.cpp
index 69d19a4dac2e..a99e74af5943 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/assign_init.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/assign_init.pass.cpp
@@ -59,7 +59,7 @@ int main()
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef min_allocator<int> A;
         typedef std::unordered_set<int,
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/assign_move.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/assign_move.pass.cpp
index e8712b7431c4..d8732268b85f 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/assign_move.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/assign_move.pass.cpp
@@ -162,7 +162,7 @@ int main()
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef min_allocator<int> A;
         typedef std::unordered_set<int,
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/compare_copy_constructible.fail.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/compare_copy_constructible.fail.cpp
new file mode 100644
index 000000000000..6b675f00f16b
--- /dev/null
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/compare_copy_constructible.fail.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_set>
+
+// Check that std::unordered_set fails to instantiate if the comparison predicate is 
+// not copy-constructible. This is LWG issue 2436
+
+#include <unordered_set>
+
+template <class T>
+struct Comp {
+	bool operator () (const T& lhs, const T& rhs) const { return lhs == rhs; }
+
+	Comp () {}
+private:
+	Comp (const Comp &); // declared but not defined
+	};
+
+
+int main() {
+	std::unordered_set<int, std::hash<int>, Comp<int> > m;
+}
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp
index e1a9b27619b7..07278be79e57 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp
@@ -105,7 +105,7 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp
index b31875befa38..59f4bfabd582 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp
@@ -65,7 +65,7 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp
index 6efa9ed8d1de..e53f381f2d6d 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp
@@ -43,7 +43,7 @@ int main()
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/default_noexcept.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/default_noexcept.pass.cpp
index f419c31c4796..3dcc3247902e 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/default_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/default_noexcept.pass.cpp
@@ -17,9 +17,12 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <unordered_set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "MoveOnly.h"
 #include "test_allocator.h"
 #include "../../../test_hash.h"
@@ -30,6 +33,7 @@ struct some_comp
     typedef T value_type;
     some_comp();
     some_comp(const some_comp&);
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 template <class T>
@@ -42,15 +46,14 @@ struct some_hash
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::unordered_set<MoveOnly> C;
-        static_assert(std::is_nothrow_default_constructible<C>::value, "");
+        LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
     }
     {
         typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>,
                            std::equal_to<MoveOnly>, test_allocator<MoveOnly>> C;
-        static_assert(std::is_nothrow_default_constructible<C>::value, "");
+        LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
     }
     {
         typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>,
@@ -66,5 +69,4 @@ int main()
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/dtor_noexcept.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/dtor_noexcept.pass.cpp
index 1e196b2e119e..b6837ccaec8d 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/dtor_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/dtor_noexcept.pass.cpp
@@ -11,19 +11,20 @@
 
 // ~unordered_set() // implied noexcept;
 
+// UNSUPPORTED: c++98, c++03
+
 #include <unordered_set>
 #include <cassert>
 
 #include "MoveOnly.h"
 #include "test_allocator.h"
 
-#if __has_feature(cxx_noexcept)
-
 template <class T>
 struct some_comp
 {
     typedef T value_type;
     ~some_comp() noexcept(false);
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 template <class T>
@@ -35,11 +36,8 @@ struct some_hash
     ~some_hash() noexcept(false);
 };
 
-#endif
-
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::unordered_set<MoveOnly> C;
         static_assert(std::is_nothrow_destructible<C>::value, "");
@@ -63,5 +61,4 @@ int main()
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/hash_copy_constructible.fail.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/hash_copy_constructible.fail.cpp
new file mode 100644
index 000000000000..066f160a2586
--- /dev/null
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/hash_copy_constructible.fail.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_map>
+
+// Check that std::unordered_set fails to instantiate if the hash function is 
+// not copy-constructible. This is mentioned in LWG issue 2436
+
+#include <unordered_set>
+
+template <class T>
+struct Hash {
+	std::size_t operator () (const T& lhs) const { return 0; }
+
+	Hash () {}
+private:
+	Hash (const Hash &); // declared but not defined
+	};
+
+
+int main() {
+	std::unordered_set<int, Hash<int> > m;
+}
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/init.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/init.pass.cpp
index 2c31d575b635..3fd0c3926c0b 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/init.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/init.pass.cpp
@@ -57,7 +57,7 @@ int main()
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/init_size.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/init_size.pass.cpp
index 340fc410109a..b7eed1e5b253 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/init_size.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/init_size.pass.cpp
@@ -60,7 +60,7 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash.pass.cpp
index fa6f0bd2ad5f..735babd522b3 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash.pass.cpp
@@ -62,7 +62,7 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal.pass.cpp
index dc3a6652ec25..643a57fa99ca 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal.pass.cpp
@@ -63,7 +63,7 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal_allocator.pass.cpp
index 1b006dbbc91c..72b9ed2a1de0 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal_allocator.pass.cpp
@@ -64,7 +64,7 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/move.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/move.pass.cpp
index f2a2a68d4036..e865986337c4 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/move.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/move.pass.cpp
@@ -103,7 +103,7 @@ int main()
 
         assert(c0.empty());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/move_alloc.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/move_alloc.pass.cpp
index 92eb36d513b6..2342bbc130be 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/move_alloc.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/move_alloc.pass.cpp
@@ -110,7 +110,7 @@ int main()
 
         assert(c0.empty());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef int P;
         typedef min_allocator<int> A;
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/move_assign_noexcept.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/move_assign_noexcept.pass.cpp
index 02af34d8f885..45f18dbbcb5c 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/move_assign_noexcept.pass.cpp
@@ -17,6 +17,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <unordered_set>
 #include <cassert>
 
@@ -28,6 +30,7 @@ struct some_comp
 {
     typedef T value_type;
     some_comp& operator=(const some_comp&);
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 template <class T>
@@ -41,7 +44,6 @@ struct some_hash
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::unordered_set<MoveOnly> C;
         static_assert(std::is_nothrow_move_assignable<C>::value, "");
@@ -65,5 +67,4 @@ int main()
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/move_noexcept.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/move_noexcept.pass.cpp
index b2d89ba5c33b..b4046148bc79 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/move_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/move_noexcept.pass.cpp
@@ -15,6 +15,8 @@
 
 // This tests a conforming extension
 
+// UNSUPPORTED: c++98, c++03
+
 #include <unordered_set>
 #include <cassert>
 
@@ -26,6 +28,7 @@ struct some_comp
 {
     typedef T value_type;
     some_comp(const some_comp&);
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 template <class T>
@@ -38,7 +41,6 @@ struct some_hash
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::unordered_set<MoveOnly> C;
         static_assert(std::is_nothrow_move_constructible<C>::value, "");
@@ -62,5 +64,4 @@ int main()
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp
index 40f3f4f4d7f9..c978d8d5d8a4 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp
@@ -60,7 +60,7 @@ int main()
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp
index ff50c712ab5d..b87d5615e00e 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp
@@ -63,7 +63,7 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp
index bcdcc5510c3c..7234d8a80aec 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp
@@ -65,7 +65,7 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp
index 632265ac861d..bcf3058aa835 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp
@@ -66,7 +66,7 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp
index ebe54fd4cbc6..ad9b414d7f13 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp
@@ -68,7 +68,7 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/size.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/size.pass.cpp
index 8f6228ad8ec4..88e499773bf3 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/size.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/size.pass.cpp
@@ -43,7 +43,7 @@ int main()
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash.pass.cpp
index 4c2c18edd1ce..eb98dcc7b7e4 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash.pass.cpp
@@ -45,7 +45,7 @@ int main()
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal.pass.cpp
index e9368782ad9a..4ae012038ae5 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal.pass.cpp
@@ -46,7 +46,7 @@ int main()
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal_allocator.pass.cpp
index 96233e187af5..b2ddbe94e741 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal_allocator.pass.cpp
@@ -47,7 +47,7 @@ int main()
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
diff --git a/test/std/containers/unord/unord.set/unord.set.swap/swap_noexcept.pass.cpp b/test/std/containers/unord/unord.set/unord.set.swap/swap_noexcept.pass.cpp
index 5d746407a80c..d35d79b31266 100644
--- a/test/std/containers/unord/unord.set/unord.set.swap/swap_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.swap/swap_noexcept.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <unordered_set>
 
 // void swap(unordered_set& c)
@@ -26,6 +28,7 @@
 #include <unordered_set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "MoveOnly.h"
 #include "test_allocator.h"
 
@@ -33,20 +36,20 @@ template <class T>
 struct some_comp
 {
     typedef T value_type;
-    
+
     some_comp() {}
     some_comp(const some_comp&) {}
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 template <class T>
 struct some_comp2
 {
     typedef T value_type;
-    
+
     some_comp2() {}
     some_comp2(const some_comp2&) {}
-    void deallocate(void*, unsigned) {}
-    typedef std::true_type propagate_on_container_swap;
+    bool operator()(const T&, const T&) const { return false; }
 };
 
 #if TEST_STD_VER >= 14
@@ -60,6 +63,7 @@ struct some_hash
     typedef T value_type;
     some_hash() {}
     some_hash(const some_hash&);
+    std::size_t operator()(const T&) const { return 0; }
 };
 
 template <class T>
@@ -68,6 +72,7 @@ struct some_hash2
     typedef T value_type;
     some_hash2() {}
     some_hash2(const some_hash2&);
+    std::size_t operator()(const T&) const { return 0; }
 };
 
 #if TEST_STD_VER >= 14
@@ -79,7 +84,7 @@ template <class T>
 struct some_alloc
 {
     typedef T value_type;
-    
+
     some_alloc() {}
     some_alloc(const some_alloc&);
     void deallocate(void*, unsigned) {}
@@ -91,7 +96,7 @@ template <class T>
 struct some_alloc2
 {
     typedef T value_type;
-    
+
     some_alloc2() {}
     some_alloc2(const some_alloc2&);
     void deallocate(void*, unsigned) {}
@@ -104,7 +109,7 @@ template <class T>
 struct some_alloc3
 {
     typedef T value_type;
-    
+
     some_alloc3() {}
     some_alloc3(const some_alloc3&);
     void deallocate(void*, unsigned) {}
@@ -115,7 +120,6 @@ struct some_alloc3
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::unordered_set<MoveOnly> C;
         C c1, c2;
@@ -193,6 +197,4 @@ int main()
     static_assert( noexcept(swap(c1, c2)), "");
     }
 #endif
-
-#endif
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp b/test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp
index 7415e2977716..2755b5285027 100644
--- a/test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp
@@ -386,7 +386,7 @@ int main()
         assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
diff --git a/test/std/depr/depr.c.headers/fenv_h.pass.cpp b/test/std/depr/depr.c.headers/fenv_h.pass.cpp
index f2fcf4914cfd..0da4c9d86b2d 100644
--- a/test/std/depr/depr.c.headers/fenv_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/fenv_h.pass.cpp
@@ -60,7 +60,7 @@
 
 int main()
 {
-    fenv_t fenv = {0};
+    fenv_t fenv = {};
     fexcept_t fex = 0;
     static_assert((std::is_same<decltype(feclearexcept(0)), int>::value), "");
     static_assert((std::is_same<decltype(fegetexceptflag(&fex, 0)), int>::value), "");
diff --git a/test/std/depr/depr.c.headers/inttypes_h.pass.cpp b/test/std/depr/depr.c.headers/inttypes_h.pass.cpp
index 637cf72287b8..ff045a913fdb 100644
--- a/test/std/depr/depr.c.headers/inttypes_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/inttypes_h.pass.cpp
@@ -917,7 +917,7 @@ int main()
     uintmax_t i4 = 0;
     }
     {
-    imaxdiv_t  i1 = {0};
+    imaxdiv_t  i1 = {};
     }
     intmax_t i = 0;
     static_assert((std::is_same<decltype(imaxabs(i)), intmax_t>::value), "");
diff --git a/test/std/depr/depr.c.headers/math_h.pass.cpp b/test/std/depr/depr.c.headers/math_h.pass.cpp
index ed12fcf73a8c..7e1b2d110642 100644
--- a/test/std/depr/depr.c.headers/math_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/math_h.pass.cpp
@@ -9,9 +9,6 @@
 
 // <math.h>
 
-// NOTE: isinf and isnan are tested separately because they are expected to fail
-// on linux. We don't want their expected failure to hide other failures in this file.
-
 #include <math.h>
 #include <type_traits>
 #include <cassert>
@@ -631,6 +628,29 @@ void test_isgreaterequal()
     assert(isgreaterequal(-1.0, 0.F) == false);
 }
 
+void test_isinf()
+{
+#ifdef isinf
+#error isinf defined
+#endif
+    static_assert((std::is_same<decltype(isinf((float)0)), bool>::value), "");
+
+    typedef decltype(isinf((double)0)) DoubleRetType;
+#ifndef __linux__
+    static_assert((std::is_same<DoubleRetType, bool>::value), "");
+#else
+    // GLIBC < 2.26 defines 'isinf(double)' with a return type of 'int' in
+    // all C++ dialects. The test should tolerate this.
+    // See: https://sourceware.org/bugzilla/show_bug.cgi?id=19439
+    static_assert((std::is_same<DoubleRetType, bool>::value
+                || std::is_same<DoubleRetType, int>::value), "");
+#endif
+
+    static_assert((std::is_same<decltype(isinf(0)), bool>::value), "");
+    static_assert((std::is_same<decltype(isinf((long double)0)), bool>::value), "");
+    assert(isinf(-1.0) == false);
+}
+
 void test_isless()
 {
 #ifdef isless
@@ -688,6 +708,29 @@ void test_islessgreater()
     assert(islessgreater(-1.0, 0.F) == true);
 }
 
+void test_isnan()
+{
+#ifdef isnan
+#error isnan defined
+#endif
+    static_assert((std::is_same<decltype(isnan((float)0)), bool>::value), "");
+
+    typedef decltype(isnan((double)0)) DoubleRetType;
+#ifndef __linux__
+    static_assert((std::is_same<DoubleRetType, bool>::value), "");
+#else
+    // GLIBC < 2.26 defines 'isnan(double)' with a return type of 'int' in
+    // all C++ dialects. The test should tolerate this.
+    // See: https://sourceware.org/bugzilla/show_bug.cgi?id=19439
+    static_assert((std::is_same<DoubleRetType, bool>::value
+                || std::is_same<DoubleRetType, int>::value), "");
+#endif
+
+    static_assert((std::is_same<decltype(isnan(0)), bool>::value), "");
+    static_assert((std::is_same<decltype(isnan((long double)0)), bool>::value), "");
+    assert(isnan(-1.0) == false);
+}
+
 void test_isunordered()
 {
 #ifdef isunordered
@@ -1443,9 +1486,11 @@ int main()
     test_isnormal();
     test_isgreater();
     test_isgreaterequal();
+    test_isinf();
     test_isless();
     test_islessequal();
     test_islessgreater();
+    test_isnan();
     test_isunordered();
     test_acosh();
     test_asinh();
diff --git a/test/std/depr/depr.c.headers/math_h_isinf.pass.cpp b/test/std/depr/depr.c.headers/math_h_isinf.pass.cpp
deleted file mode 100644
index cc7eaac7de62..000000000000
--- a/test/std/depr/depr.c.headers/math_h_isinf.pass.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// <math.h>
-
-// isinf
-
-// XFAIL: linux
-
-#include <math.h>
-#include <type_traits>
-#include <cassert>
-
-int main()
-{
-#ifdef isinf
-#error isinf defined
-#endif
-    static_assert((std::is_same<decltype(isinf((float)0)), bool>::value), "");
-    static_assert((std::is_same<decltype(isinf((double)0)), bool>::value), "");
-    static_assert((std::is_same<decltype(isinf(0)), bool>::value), "");
-    static_assert((std::is_same<decltype(isinf((long double)0)), bool>::value), "");
-    assert(isinf(-1.0) == false);
-}
diff --git a/test/std/depr/depr.c.headers/math_h_isnan.pass.cpp b/test/std/depr/depr.c.headers/math_h_isnan.pass.cpp
deleted file mode 100644
index 118f96bdd434..000000000000
--- a/test/std/depr/depr.c.headers/math_h_isnan.pass.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// <math.h>
-
-// isnan
-
-// XFAIL: linux
-
-#include <math.h>
-#include <type_traits>
-#include <cassert>
-
-int main()
-{
-#ifdef isnan
-#error isnan defined
-#endif
-    static_assert((std::is_same<decltype(isnan((float)0)), bool>::value), "");
-    static_assert((std::is_same<decltype(isnan((double)0)), bool>::value), "");
-    static_assert((std::is_same<decltype(isnan(0)), bool>::value), "");
-    static_assert((std::is_same<decltype(isnan((long double)0)), bool>::value), "");
-    assert(isnan(-1.0) == false);
-}
diff --git a/test/std/depr/depr.c.headers/setjmp_h.pass.cpp b/test/std/depr/depr.c.headers/setjmp_h.pass.cpp
index 9bc35b747493..9663d8892ac5 100644
--- a/test/std/depr/depr.c.headers/setjmp_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/setjmp_h.pass.cpp
@@ -19,6 +19,7 @@
 int main()
 {
     jmp_buf jb;
+    ((void)jb); // Prevent unused warning
     static_assert((std::is_same<decltype(longjmp(jb, 0)), void>::value),
                   "std::is_same<decltype(longjmp(jb, 0)), void>::value");
 }
diff --git a/test/std/depr/depr.c.headers/stdarg_h.pass.cpp b/test/std/depr/depr.c.headers/stdarg_h.pass.cpp
index f7d12b1ad551..e3c38801e4a8 100644
--- a/test/std/depr/depr.c.headers/stdarg_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/stdarg_h.pass.cpp
@@ -11,11 +11,13 @@
 
 #include <stdarg.h>
 
+#include "test_macros.h"
+
 #ifndef va_arg
 #error va_arg not defined
 #endif
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
 #  ifndef va_copy
 #    error va_copy is not defined when c++ >= 11
 #  endif
diff --git a/test/std/depr/depr.c.headers/stdint_h.pass.cpp b/test/std/depr/depr.c.headers/stdint_h.pass.cpp
index 92bb04e558bb..3d49111fd82b 100644
--- a/test/std/depr/depr.c.headers/stdint_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/stdint_h.pass.cpp
@@ -171,8 +171,8 @@ int main()
     // INTN_MIN
     static_assert(INT8_MIN == -128, "INT8_MIN == -128");
     static_assert(INT16_MIN == -32768, "INT16_MIN == -32768");
-    static_assert(INT32_MIN == -2147483648U, "INT32_MIN == -2147483648");
-    static_assert(INT64_MIN == -9223372036854775808ULL, "INT64_MIN == -9223372036854775808LL");
+    static_assert(INT32_MIN == -2147483647 - 1, "INT32_MIN == -2147483648");
+    static_assert(INT64_MIN == -9223372036854775807LL - 1, "INT64_MIN == -9223372036854775808LL");
 
     // INTN_MAX
     static_assert(INT8_MAX == 127, "INT8_MAX == 127");
@@ -189,8 +189,8 @@ int main()
     // INT_FASTN_MIN
     static_assert(INT_FAST8_MIN <= -128, "INT_FAST8_MIN <= -128");
     static_assert(INT_FAST16_MIN <= -32768, "INT_FAST16_MIN <= -32768");
-    static_assert(INT_FAST32_MIN <= -2147483648U, "INT_FAST32_MIN <= -2147483648");
-    static_assert(INT_FAST64_MIN <= -9223372036854775808ULL, "INT_FAST64_MIN <= -9223372036854775808LL");
+    static_assert(INT_FAST32_MIN <= -2147483647 - 1, "INT_FAST32_MIN <= -2147483648");
+    static_assert(INT_FAST64_MIN <= -9223372036854775807LL - 1, "INT_FAST64_MIN <= -9223372036854775808LL");
 
     // INT_FASTN_MAX
     static_assert(INT_FAST8_MAX >= 127, "INT_FAST8_MAX >= 127");
diff --git a/test/std/depr/depr.c.headers/stdio_h.pass.cpp b/test/std/depr/depr.c.headers/stdio_h.pass.cpp
index 3c5dd0ebf0e0..85f9d2986284 100644
--- a/test/std/depr/depr.c.headers/stdio_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/stdio_h.pass.cpp
@@ -99,17 +99,25 @@
 
 #include <cstdarg>
 
+#if defined(__GNUC__)
 #pragma GCC diagnostic ignored "-Wformat-zero-length"
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations" // for tmpnam
+#endif
 
 int main()
 {
     FILE* fp = 0;
-    fpos_t fpos = {0};
-    size_t s = 0; ((void)s);
+    fpos_t fpos = {};
+    size_t s = 0;
     char* cp = 0;
     char arr[] = {'a', 'b'};
     va_list va;
+    ((void)fp); // Prevent unused warning
+    ((void)fpos); // Prevent unused warning
+    ((void)s); // Prevent unused warning
+    ((void)cp); // Prevent unused warning
+    ((void)arr); // Prevent unused warning
+    ((void)va); // Prevent unused warning
     static_assert((std::is_same<decltype(remove("")), int>::value), "");
     static_assert((std::is_same<decltype(rename("","")), int>::value), "");
     static_assert((std::is_same<decltype(tmpfile()), FILE*>::value), "");
diff --git a/test/std/depr/depr.c.headers/string_h.pass.cpp b/test/std/depr/depr.c.headers/string_h.pass.cpp
index afc784f74b89..db0308b7ef82 100644
--- a/test/std/depr/depr.c.headers/string_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/string_h.pass.cpp
@@ -47,4 +47,15 @@ int main()
     static_assert((std::is_same<decltype(memset(vp, 0, s)), void*>::value), "");
     static_assert((std::is_same<decltype(strerror(0)), char*>::value), "");
     static_assert((std::is_same<decltype(strlen(cpc)), size_t>::value), "");
+
+    // These tests fail on systems whose C library doesn't provide a correct overload
+    // set for strchr, strpbrk, strrchr, strstr, and memchr, unless the compiler is
+    // a suitably recent version of Clang.
+#if !defined(__APPLE__) || defined(_LIBCPP_PREFERRED_OVERLOAD)
+    static_assert((std::is_same<decltype(strchr(cpc, 0)), const char*>::value), "");
+    static_assert((std::is_same<decltype(strpbrk(cpc, cpc)), const char*>::value), "");
+    static_assert((std::is_same<decltype(strrchr(cpc, 0)), const char*>::value), "");
+    static_assert((std::is_same<decltype(strstr(cpc, cpc)), const char*>::value), "");
+    static_assert((std::is_same<decltype(memchr(vpc, 0, s)), const void*>::value), "");
+#endif
 }
diff --git a/test/std/depr/depr.c.headers/time_h.pass.cpp b/test/std/depr/depr.c.headers/time_h.pass.cpp
index 0d229af409bd..a2639383cda7 100644
--- a/test/std/depr/depr.c.headers/time_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/time_h.pass.cpp
@@ -25,7 +25,7 @@ int main()
     clock_t c = 0; ((void)c);
     size_t s = 0;
     time_t t = 0;
-    tm tmv = {0};
+    tm tmv = {};
     static_assert((std::is_same<decltype(clock()), clock_t>::value), "");
     static_assert((std::is_same<decltype(difftime(t,t)), double>::value), "");
     static_assert((std::is_same<decltype(mktime(&tmv)), time_t>::value), "");
diff --git a/test/std/depr/depr.c.headers/wchar_h.pass.cpp b/test/std/depr/depr.c.headers/wchar_h.pass.cpp
index e561b3e5a724..f2e42a328588 100644
--- a/test/std/depr/depr.c.headers/wchar_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/wchar_h.pass.cpp
@@ -9,8 +9,8 @@
 
 // <wchar.h>
 
-
 #include <wchar.h>
+#include <stdarg.h>
 #include <type_traits>
 
 #ifndef NULL
@@ -32,25 +32,25 @@
 int main()
 {
 // mbstate_t comes from the underlying C library; it is defined (in C99) as:
-//    a complete object type other than an array type that can hold the conversion 
-//    state information necessary to convert between sequences of multibyte 
+//    a complete object type other than an array type that can hold the conversion
+//    state information necessary to convert between sequences of multibyte
 //    characters and wide characters
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wmissing-braces"
-    mbstate_t mb = {0};
-#pragma clang diagnostic pop
-
+    mbstate_t mb = {};
     size_t s = 0;
     tm *tm = 0;
     wint_t w = 0;
     ::FILE* fp = 0;
-#ifdef __APPLE__
-    __darwin_va_list va;
-#else
-    __builtin_va_list va;
-#endif
+    ::va_list va;
     char* ns = 0;
     wchar_t* ws = 0;
+    ((void)mb); // Prevent unused warning
+    ((void)s); // Prevent unused warning
+    ((void)tm); // Prevent unused warning
+    ((void)w); // Prevent unused warning
+    ((void)fp); // Prevent unused warning
+    ((void)va); // Prevent unused warning
+    ((void)ns); // Prevent unused warning
+    ((void)ws); // Prevent unused warning
     static_assert((std::is_same<decltype(fwprintf(fp, L"")), int>::value), "");
     static_assert((std::is_same<decltype(fwscanf(fp, L"")), int>::value), "");
     static_assert((std::is_same<decltype(swprintf(ws, s, L"")), int>::value), "");
@@ -82,19 +82,14 @@ int main()
     static_assert((std::is_same<decltype(wcscoll(L"", L"")), int>::value), "");
     static_assert((std::is_same<decltype(wcsncmp(L"", L"", s)), int>::value), "");
     static_assert((std::is_same<decltype(wcsxfrm(ws, L"", s)), size_t>::value), "");
-    // const wchar_t* wcschr((const wchar_t*)0, L' ') - See below
     static_assert((std::is_same<decltype(wcschr((wchar_t*)0, L' ')), wchar_t*>::value), "");
     static_assert((std::is_same<decltype(wcscspn(L"", L"")), size_t>::value), "");
     static_assert((std::is_same<decltype(wcslen(L"")), size_t>::value), "");
-    // const wchar_t* wcspbrk((const wchar_t*)0, L"") - See below
     static_assert((std::is_same<decltype(wcspbrk((wchar_t*)0, L"")), wchar_t*>::value), "");
-    // const wchar_t* wcsrchr((const wchar_t*)0, L' ') - See below
     static_assert((std::is_same<decltype(wcsrchr((wchar_t*)0, L' ')), wchar_t*>::value), "");
     static_assert((std::is_same<decltype(wcsspn(L"", L"")), size_t>::value), "");
-    // const wchar_t* wcsstr((const wchar_t*)0, L"") - See below
     static_assert((std::is_same<decltype(wcsstr((wchar_t*)0, L"")), wchar_t*>::value), "");
     static_assert((std::is_same<decltype(wcstok(ws, L"", (wchar_t**)0)), wchar_t*>::value), "");
-    // const wchar_t* wmemchr((const wchar_t*)0, L' ', s) - See below
     static_assert((std::is_same<decltype(wmemchr((wchar_t*)0, L' ', s)), wchar_t*>::value), "");
     static_assert((std::is_same<decltype(wmemcmp(L"", L"", s)), int>::value), "");
     static_assert((std::is_same<decltype(wmemcpy(ws, L"", s)), wchar_t*>::value), "");
@@ -110,10 +105,10 @@ int main()
     static_assert((std::is_same<decltype(mbsrtowcs(ws, (const char**)0, s, &mb)), size_t>::value), "");
     static_assert((std::is_same<decltype(wcsrtombs(ns, (const wchar_t**)0, s, &mb)), size_t>::value), "");
 
-// This test fails on systems whose C library doesn't provide a correct overload
-// set for wcschr, wcspbrk, wcsrchr, wcsstr, and wmemchr. There's no way for
-// libc++ to fix that on the C library's behalf.
-#ifndef __APPLE__
+    // These tests fail on systems whose C library doesn't provide a correct overload
+    // set for wcschr, wcspbrk, wcsrchr, wcsstr, and wmemchr, unless the compiler is
+    // a suitably recent version of Clang.
+#if !defined(__APPLE__) || defined(_LIBCPP_PREFERRED_OVERLOAD)
     static_assert((std::is_same<decltype(wcschr((const wchar_t*)0, L' ')), const wchar_t*>::value), "");
     static_assert((std::is_same<decltype(wcspbrk((const wchar_t*)0, L"")), const wchar_t*>::value), "");
     static_assert((std::is_same<decltype(wcsrchr((const wchar_t*)0, L' ')), const wchar_t*>::value), "");
diff --git a/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/ccp.pass.cpp b/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/ccp.pass.cpp
index 9911df715078..078d8911d8a6 100644
--- a/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/ccp.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/ccp.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <strstream>
 #include <cassert>
+#include <string>
 
 int main()
 {
diff --git a/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/ccp_size.pass.cpp b/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/ccp_size.pass.cpp
index a80095099401..8b4ae722f224 100644
--- a/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/ccp_size.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/ccp_size.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <strstream>
 #include <cassert>
+#include <string>
 
 int main()
 {
diff --git a/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/cp.pass.cpp b/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/cp.pass.cpp
index edd6c1f6286c..23068f5fd332 100644
--- a/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/cp.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/cp.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <strstream>
 #include <cassert>
+#include <string>
 
 int main()
 {
diff --git a/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/cp_size.pass.cpp b/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/cp_size.pass.cpp
index 5d01715ba1b7..ff797e092947 100644
--- a/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/cp_size.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/cp_size.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <strstream>
 #include <cassert>
+#include <string>
 
 int main()
 {
diff --git a/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.cons/cp_size_mode.pass.cpp b/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.cons/cp_size_mode.pass.cpp
index 1ad0bfa8e269..b6519de8eddd 100644
--- a/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.cons/cp_size_mode.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.cons/cp_size_mode.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <strstream>
 #include <cassert>
+#include <string>
 
 int main()
 {
diff --git a/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.cons/default.pass.cpp b/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.cons/default.pass.cpp
index 5ea4988ffa6f..29debf187c7e 100644
--- a/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.cons/default.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.cons/default.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <strstream>
 #include <cassert>
+#include <string>
 
 int main()
 {
diff --git a/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.cons/cp_size_mode.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.cons/cp_size_mode.pass.cpp
index 2a4c0ec5aa20..1dc03b8aa806 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.cons/cp_size_mode.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.cons/cp_size_mode.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <strstream>
 #include <cassert>
+#include <string>
 
 int main()
 {
diff --git a/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.cons/default.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.cons/default.pass.cpp
index 2ec5e7f748e1..6298fcac30a9 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.cons/default.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.cons/default.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <strstream>
 #include <cassert>
+#include <string>
 
 int main()
 {
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/custom_alloc.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/custom_alloc.pass.cpp
index 12a1fb874c30..e466d50c64f6 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/custom_alloc.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/custom_alloc.pass.cpp
@@ -18,7 +18,7 @@
 
 int called = 0;
 
-void* my_alloc(std::size_t n)
+void* my_alloc(std::size_t)
 {
     static char buf[10000];
     ++called;
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/overflow.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/overflow.pass.cpp
new file mode 100644
index 000000000000..dda19a9517fb
--- /dev/null
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/overflow.pass.cpp
@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <strstream>
+
+// class strstreambuf
+
+// int overflow(int c);
+
+#include <iostream>
+#include <string>
+#include <strstream>
+
+int main() {
+  std::ostrstream oss;
+  std::string s;
+
+  for (int i = 0; i < 4096; ++i)
+    s.push_back((i % 16) + 'a');
+
+  oss << s << std::ends;
+  std::cout << oss.str();
+  oss.freeze(false);
+
+  return 0;
+}
diff --git a/test/std/depr/exception.unexpected/set.unexpected/get_unexpected.pass.cpp b/test/std/depr/exception.unexpected/set.unexpected/get_unexpected.pass.cpp
index 8b0a0b979de0..02f9a81aa6dd 100644
--- a/test/std/depr/exception.unexpected/set.unexpected/get_unexpected.pass.cpp
+++ b/test/std/depr/exception.unexpected/set.unexpected/get_unexpected.pass.cpp
@@ -23,7 +23,7 @@ void f3()
 
 int main()
 {
-    
+
     std::unexpected_handler old = std::get_unexpected();
     // verify there is a previous unexpected handler
     assert(old);
diff --git a/test/std/diagnostics/assertions/cassert.pass.cpp b/test/std/diagnostics/assertions/cassert.pass.cpp
index bed7a394ee4a..3f886e7b91fd 100644
--- a/test/std/diagnostics/assertions/cassert.pass.cpp
+++ b/test/std/diagnostics/assertions/cassert.pass.cpp
@@ -15,10 +15,6 @@
 #error assert not defined
 #endif
 
-#ifndef _LIBCPP_VERSION
-#error _LIBCPP_VERSION not defined
-#endif
-
 int main()
 {
 }
diff --git a/test/std/diagnostics/errno/cerrno.pass.cpp b/test/std/diagnostics/errno/cerrno.pass.cpp
index c6743fb79e7f..72c9371d16c4 100644
--- a/test/std/diagnostics/errno/cerrno.pass.cpp
+++ b/test/std/diagnostics/errno/cerrno.pass.cpp
@@ -12,10 +12,6 @@
 
 #include <cerrno>
 
-#ifndef _LIBCPP_VERSION
-#error _LIBCPP_VERSION not defined
-#endif
-
 #ifndef E2BIG
 #error E2BIG not defined
 #endif
diff --git a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/default_ctor.pass.cpp b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/default_ctor.pass.cpp
index 0573ef862efd..f6a97ef92d84 100644
--- a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/default_ctor.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/default_ctor.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <system_error>
 
 // class error_category
@@ -18,23 +19,17 @@
 #include <string>
 #include <cassert>
 
-#if _LIBCPP_STD_VER > 11
-
 class test1
     : public std::error_category
 {
 public:
     constexpr test1() = default;  // won't compile if error_category() is not constexpr
     virtual const char* name() const noexcept {return nullptr;}
-    virtual std::string message(int ev) const {return std::string();}
+    virtual std::string message(int) const {return std::string();}
 };
 
-#endif  // _LIBCPP_STD_VER > 11
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     static_assert(std::is_nothrow_default_constructible<test1>::value,
                                  "error_category() must exist and be noexcept");
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/generic_category.pass.cpp b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/generic_category.pass.cpp
index 972299936ddf..65ecc4921212 100644
--- a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/generic_category.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/generic_category.pass.cpp
@@ -16,10 +16,24 @@
 #include <system_error>
 #include <cassert>
 #include <string>
+#include <cerrno>
+
+#include "test_macros.h"
+
+void test_message_for_bad_value() {
+    errno = E2BIG; // something that message will never generate
+    const std::error_category& e_cat1 = std::generic_category();
+    const std::string msg = e_cat1.message(-1);
+    LIBCPP_ASSERT(msg == "Unknown error -1");
+    assert(errno == E2BIG);
+}
 
 int main()
 {
     const std::error_category& e_cat1 = std::generic_category();
     std::string m1 = e_cat1.name();
     assert(m1 == "generic");
+    {
+        test_message_for_bad_value();
+    }
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/system_category.pass.cpp b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/system_category.pass.cpp
index b5cb18ad7653..d1a94883f925 100644
--- a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/system_category.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/system_category.pass.cpp
@@ -16,6 +16,17 @@
 #include <system_error>
 #include <cassert>
 #include <string>
+#include <cerrno>
+
+#include "test_macros.h"
+
+void test_message_for_bad_value() {
+    errno = E2BIG; // something that message will never generate
+    const std::error_category& e_cat1 = std::system_category();
+    const std::string msg = e_cat1.message(-1);
+    LIBCPP_ASSERT(msg == "Unknown error -1");
+    assert(errno == E2BIG);
+}
 
 int main()
 {
@@ -26,4 +37,7 @@ int main()
     e_cond = e_cat1.default_error_condition(5000);
     assert(e_cond.value() == 5000);
     assert(e_cond.category() == std::system_category());
+    {
+        test_message_for_bad_value();
+    }
 }
diff --git a/test/std/diagnostics/syserr/syserr.hash/error_code.pass.cpp b/test/std/diagnostics/syserr/syserr.hash/error_code.pass.cpp
index b812e364bbc5..c8b3d98103c4 100644
--- a/test/std/diagnostics/syserr/syserr.hash/error_code.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.hash/error_code.pass.cpp
@@ -16,12 +16,12 @@
 //     size_t operator()(T val) const;
 // };
 
-// Not very portable
-
 #include <system_error>
 #include <cassert>
 #include <type_traits>
 
+#include "test_macros.h"
+
 void
 test(int i)
 {
@@ -31,7 +31,9 @@ test(int i)
     static_assert((std::is_same<H::result_type, std::size_t>::value), "" );
     H h;
     T ec(i, std::system_category());
-    assert(h(ec) == i);
+    const std::size_t result = h(ec);
+    LIBCPP_ASSERT(result == i);
+    ((void)result); // Prevent unused warning
 }
 
 int main()
diff --git a/test/std/experimental/algorithms/alg.random.sample/sample.pass.cpp b/test/std/experimental/algorithms/alg.random.sample/sample.pass.cpp
index 0f0784d6ee90..1a9f9b099b20 100644
--- a/test/std/experimental/algorithms/alg.random.sample/sample.pass.cpp
+++ b/test/std/experimental/algorithms/alg.random.sample/sample.pass.cpp
@@ -64,12 +64,12 @@ void test() {
   end = std::experimental::sample(PopulationIterator(ia),
                                   PopulationIterator(ia + is),
                                   SampleIterator(oa), os, g);
-  assert(&*end - oa == std::min(os, is));
+  assert(end.base() - oa == std::min(os, is));
   assert(std::equal(oa, oa + os, oa1));
   end = std::experimental::sample(PopulationIterator(ia),
                                   PopulationIterator(ia + is),
                                   SampleIterator(oa), os, g);
-  assert(&*end - oa == std::min(os, is));
+  assert(end.base() - oa == std::min(os, is));
   assert(std::equal(oa, oa + os, oa2));
 }
 
@@ -85,7 +85,7 @@ void test_empty_population() {
   SampleIterator end =
       std::experimental::sample(PopulationIterator(ia), PopulationIterator(ia),
                                 SampleIterator(oa), os, g);
-  assert(&*end == oa);
+  assert(end.base() == oa);
 }
 
 template <template<class> class PopulationIteratorType, class PopulationItem,
@@ -100,7 +100,7 @@ void test_empty_sample() {
   SampleIterator end =
       std::experimental::sample(PopulationIterator(ia), PopulationIterator(ia + is),
                                 SampleIterator(oa), 0, g);
-  assert(&*end == oa);
+  assert(end.base() == oa);
 }
 
 template <template<class> class PopulationIteratorType, class PopulationItem,
@@ -119,8 +119,8 @@ void test_small_population() {
   end = std::experimental::sample(PopulationIterator(ia),
                                   PopulationIterator(ia + is),
                                   SampleIterator(oa), os, g);
-  assert(&*end - oa == std::min(os, is));
-  assert(std::equal(oa, &*end, oa1));
+  assert(end.base() - oa == std::min(os, is));
+  assert(std::equal(oa, end.base(), oa1));
 }
 
 int main() {
diff --git a/test/std/experimental/algorithms/alg.search/search.pass.cpp b/test/std/experimental/algorithms/alg.search/search.pass.cpp
index 60a44e4c26a2..81d220ba1aed 100644
--- a/test/std/experimental/algorithms/alg.search/search.pass.cpp
+++ b/test/std/experimental/algorithms/alg.search/search.pass.cpp
@@ -15,7 +15,7 @@
 //   ForwardIterator search(ForwardIterator first, ForwardIterator last,
 //                          const Searcher& searcher);
 //
-//		returns searcher.operator(first, last)
+//		returns searcher.operator(first, last).first
 //
 
 #include <experimental/algorithm>
@@ -27,10 +27,11 @@ int searcher_called = 0;
 
 struct MySearcher {
     template <typename Iterator>
-    Iterator operator() ( Iterator b, Iterator /*e*/) const 
+    std::pair<Iterator, Iterator>
+    operator() (Iterator b, Iterator e) const
     {
         ++searcher_called;
-        return b;
+        return std::make_pair(b, e);
     }
 };
 
diff --git a/test/std/experimental/filesystem/Inputs/static_test_env/bad_symlink b/test/std/experimental/filesystem/Inputs/static_test_env/bad_symlink
new file mode 120000
index 000000000000..76646beed5ed
--- /dev/null
+++ b/test/std/experimental/filesystem/Inputs/static_test_env/bad_symlink
@@ -0,0 +1 @@
+dne
\ No newline at end of file
diff --git a/test/std/experimental/filesystem/Inputs/static_test_env/dir1/dir2/afile3 b/test/std/experimental/filesystem/Inputs/static_test_env/dir1/dir2/afile3
new file mode 100644
index 000000000000..e69de29bb2d1
--- /dev/null
+++ b/test/std/experimental/filesystem/Inputs/static_test_env/dir1/dir2/afile3
diff --git a/test/std/experimental/filesystem/Inputs/static_test_env/dir1/dir2/dir3/file5 b/test/std/experimental/filesystem/Inputs/static_test_env/dir1/dir2/dir3/file5
new file mode 100644
index 000000000000..e69de29bb2d1
--- /dev/null
+++ b/test/std/experimental/filesystem/Inputs/static_test_env/dir1/dir2/dir3/file5
diff --git a/test/std/experimental/filesystem/Inputs/static_test_env/dir1/dir2/file4 b/test/std/experimental/filesystem/Inputs/static_test_env/dir1/dir2/file4
new file mode 100644
index 000000000000..e69de29bb2d1
--- /dev/null
+++ b/test/std/experimental/filesystem/Inputs/static_test_env/dir1/dir2/file4
diff --git a/test/std/experimental/filesystem/Inputs/static_test_env/dir1/dir2/symlink_to_dir3 b/test/std/experimental/filesystem/Inputs/static_test_env/dir1/dir2/symlink_to_dir3
new file mode 120000
index 000000000000..397913952621
--- /dev/null
+++ b/test/std/experimental/filesystem/Inputs/static_test_env/dir1/dir2/symlink_to_dir3
@@ -0,0 +1 @@
+dir3
\ No newline at end of file
diff --git a/test/std/experimental/filesystem/Inputs/static_test_env/dir1/file1 b/test/std/experimental/filesystem/Inputs/static_test_env/dir1/file1
new file mode 100644
index 000000000000..e69de29bb2d1
--- /dev/null
+++ b/test/std/experimental/filesystem/Inputs/static_test_env/dir1/file1
diff --git a/test/std/experimental/filesystem/Inputs/static_test_env/dir1/file2 b/test/std/experimental/filesystem/Inputs/static_test_env/dir1/file2
new file mode 100644
index 000000000000..44834e586734
--- /dev/null
+++ b/test/std/experimental/filesystem/Inputs/static_test_env/dir1/file2
@@ -0,0 +1 @@
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
\ No newline at end of file
diff --git a/test/std/experimental/filesystem/Inputs/static_test_env/empty_file b/test/std/experimental/filesystem/Inputs/static_test_env/empty_file
new file mode 100644
index 000000000000..e69de29bb2d1
--- /dev/null
+++ b/test/std/experimental/filesystem/Inputs/static_test_env/empty_file
diff --git a/test/std/experimental/filesystem/Inputs/static_test_env/non_empty_file b/test/std/experimental/filesystem/Inputs/static_test_env/non_empty_file
new file mode 100644
index 000000000000..44834e586734
--- /dev/null
+++ b/test/std/experimental/filesystem/Inputs/static_test_env/non_empty_file
@@ -0,0 +1 @@
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
\ No newline at end of file
diff --git a/test/std/experimental/filesystem/Inputs/static_test_env/symlink_to_dir b/test/std/experimental/filesystem/Inputs/static_test_env/symlink_to_dir
new file mode 120000
index 000000000000..df490f837a85
--- /dev/null
+++ b/test/std/experimental/filesystem/Inputs/static_test_env/symlink_to_dir
@@ -0,0 +1 @@
+dir1
\ No newline at end of file
diff --git a/test/std/experimental/filesystem/Inputs/static_test_env/symlink_to_empty_file b/test/std/experimental/filesystem/Inputs/static_test_env/symlink_to_empty_file
new file mode 120000
index 000000000000..b79b689fc85a
--- /dev/null
+++ b/test/std/experimental/filesystem/Inputs/static_test_env/symlink_to_empty_file
@@ -0,0 +1 @@
+empty_file
\ No newline at end of file
diff --git a/test/std/experimental/filesystem/class.directory_entry/directory_entry.cons.pass.cpp b/test/std/experimental/filesystem/class.directory_entry/directory_entry.cons.pass.cpp
new file mode 100644
index 000000000000..9a92f0698ba7
--- /dev/null
+++ b/test/std/experimental/filesystem/class.directory_entry/directory_entry.cons.pass.cpp
@@ -0,0 +1,97 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class directory_entry
+
+//          directory_entry() noexcept = default;
+//          directory_entry(const directory_entry&) = default;
+//          directory_entry(directory_entry&&) noexcept = default;
+// explicit directory_entry(const path);
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+namespace fs = std::experimental::filesystem;
+
+void test_default_ctor()
+{
+  using namespace fs;
+  // Default
+  {
+    static_assert(std::is_nothrow_default_constructible<directory_entry>::value,
+                  "directory_entry must have a nothrow default constructor");
+    directory_entry e;
+    assert(e.path() == path());
+  }
+}
+
+
+void test_copy_ctor()
+{
+  using namespace fs;
+  // Copy
+  {
+    static_assert(std::is_copy_constructible<directory_entry>::value,
+                  "directory_entry must be copy constructible");
+    static_assert(!std::is_nothrow_copy_constructible<directory_entry>::value,
+                  "directory_entry's copy constructor cannot be noexcept");
+    const path p("foo/bar/baz");
+    const directory_entry e(p);
+    assert(e.path() == p);
+    directory_entry e2(e);
+    assert(e.path() == p);
+    assert(e2.path() == p);
+  }
+
+}
+
+void test_move_ctor()
+{
+  using namespace fs;
+  // Move
+  {
+    static_assert(std::is_nothrow_move_constructible<directory_entry>::value,
+                  "directory_entry must be nothrow move constructible");
+    const path p("foo/bar/baz");
+    directory_entry e(p);
+    assert(e.path() == p);
+    directory_entry e2(std::move(e));
+    assert(e2.path() == p);
+    assert(e.path()  != p); // Testing moved from state.
+  }
+}
+
+void test_path_ctor() {
+  using namespace fs;
+  {
+    static_assert(std::is_constructible<directory_entry, const path&>::value,
+                  "directory_entry must be constructible from path");
+    static_assert(!std::is_nothrow_constructible<directory_entry, const path&>::value,
+                  "directory_entry constructor should not be noexcept");
+    static_assert(!std::is_convertible<path const&, directory_entry>::value,
+                  "directory_entry constructor should be explicit");
+  }
+  {
+    const path p("foo/bar/baz");
+    const directory_entry e(p);
+    assert(p == e.path());
+  }
+}
+
+int main() {
+  test_default_ctor();
+  test_copy_ctor();
+  test_move_ctor();
+  test_path_ctor();
+}
diff --git a/test/std/experimental/filesystem/class.directory_entry/directory_entry.mods.pass.cpp b/test/std/experimental/filesystem/class.directory_entry/directory_entry.mods.pass.cpp
new file mode 100644
index 000000000000..97ecbefac42a
--- /dev/null
+++ b/test/std/experimental/filesystem/class.directory_entry/directory_entry.mods.pass.cpp
@@ -0,0 +1,113 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class directory_entry
+
+// directory_entry& operator=(directory_entry const&) = default;
+// directory_entry& operator=(directory_entry&&) noexcept = default;
+// void assign(path const&);
+// void replace_filename(path const&);
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+namespace fs = std::experimental::filesystem;
+
+void test_copy_assign_operator()
+{
+  using namespace fs;
+  // Copy
+  {
+    static_assert(std::is_copy_assignable<directory_entry>::value,
+                  "directory_entry must be copy assignable");
+    static_assert(!std::is_nothrow_copy_assignable<directory_entry>::value,
+                  "directory_entry's copy assignment cannot be noexcept");
+    const path p("foo/bar/baz");
+    const path p2("abc");
+    const directory_entry e(p);
+    directory_entry e2;
+    assert(e.path() == p && e2.path() == path());
+    e2 = e;
+    assert(e.path() == p && e2.path() == p);
+    directory_entry e3(p2);
+    e2 = e3;
+    assert(e2.path() == p2 && e3.path() == p2);
+  }
+}
+
+
+void test_move_assign_operator()
+{
+  using namespace fs;
+  // Copy
+  {
+    static_assert(std::is_nothrow_move_assignable<directory_entry>::value,
+                  "directory_entry is noexcept move assignable");
+    const path p("foo/bar/baz");
+    const path p2("abc");
+    directory_entry e(p);
+    directory_entry e2(p2);
+    assert(e.path() == p && e2.path() == p2);
+    e2 = std::move(e);
+    assert(e2.path() == p);
+    assert(e.path() != p); // testing moved from state
+  }
+}
+
+void test_path_assign_method()
+{
+  using namespace fs;
+  const path p("foo/bar/baz");
+  const path p2("abc");
+  directory_entry e(p);
+  {
+    static_assert(std::is_same<decltype(e.assign(p)), void>::value,
+                  "return type should be void");
+    static_assert(noexcept(e.assign(p)) == false, "operation must not be noexcept");
+  }
+  {
+    assert(e.path() == p);
+    e.assign(p2);
+    assert(e.path() == p2 && e.path() != p);
+    e.assign(p);
+    assert(e.path() == p && e.path() != p2);
+  }
+}
+
+void test_replace_filename_method()
+{
+  using namespace fs;
+  const path p("/path/to/foo.exe");
+  const path replace("bar.out");
+  const path expect("/path/to/bar.out");
+  directory_entry e(p);
+  {
+    static_assert(noexcept(e.replace_filename(replace)) == false,
+                  "operation cannot be noexcept");
+    static_assert(std::is_same<decltype(e.replace_filename(replace)), void>::value,
+                  "operation must return void");
+  }
+  {
+    assert(e.path() == p);
+    e.replace_filename(replace);
+    assert(e.path() == expect);
+  }
+}
+
+int main() {
+  test_copy_assign_operator();
+  test_move_assign_operator();
+  test_path_assign_method();
+  test_replace_filename_method();
+}
diff --git a/test/std/experimental/filesystem/class.directory_entry/directory_entry.obs/comparisons.pass.cpp b/test/std/experimental/filesystem/class.directory_entry/directory_entry.obs/comparisons.pass.cpp
new file mode 100644
index 000000000000..96e509300229
--- /dev/null
+++ b/test/std/experimental/filesystem/class.directory_entry/directory_entry.obs/comparisons.pass.cpp
@@ -0,0 +1,82 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class directory_entry
+
+// bool operator==(directory_entry const&) const noexcept;
+// bool operator!=(directory_entry const&) const noexcept;
+// bool operator< (directory_entry const&) const noexcept;
+// bool operator<=(directory_entry const&) const noexcept;
+// bool operator> (directory_entry const&) const noexcept;
+// bool operator>=(directory_entry const&) const noexcept;
+
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+namespace fs = std::experimental::filesystem;
+
+#define CHECK_OP(Op) \
+  static_assert(std::is_same<decltype(ce. operator Op (ce)), bool>::value, ""); \
+  static_assert(noexcept(ce.operator Op (ce)), "Operation must be noexcept" )
+
+void test_comparison_signatures() {
+  using namespace fs;
+  path const p("foo/bar/baz");
+  // Check that the operators are member functions with the correct signatures.
+  {
+    directory_entry const ce(p);
+    CHECK_OP(==);
+    CHECK_OP(!=);
+    CHECK_OP(< );
+    CHECK_OP(<=);
+    CHECK_OP(> );
+    CHECK_OP(>=);
+  }
+}
+#undef CHECK_OP
+
+// The actual semantics of the comparisons are testing via paths operators.
+void test_comparisons_simple() {
+  using namespace fs;
+  typedef std::pair<path, path> TestType;
+  TestType TestCases[] =
+  {
+      {"", ""},
+      {"", "a"},
+      {"a", "a"},
+      {"a", "b"},
+      {"foo/bar/baz", "foo/bar/baz/"}
+  };
+  auto TestFn = [](path const& LHS, const directory_entry& LHSE,
+                   path const& RHS, const directory_entry& RHSE) {
+    assert((LHS == RHS) == (LHSE == RHSE));
+    assert((LHS != RHS) == (LHSE != RHSE));
+    assert((LHS < RHS) ==  (LHSE < RHSE));
+    assert((LHS <= RHS) == (LHSE <= RHSE));
+    assert((LHS > RHS) ==  (LHSE > RHSE));
+    assert((LHS >= RHS) == (LHSE >= RHSE));
+  };
+  for (auto const& TC : TestCases) {
+    const directory_entry L(TC.first);
+    const directory_entry R(TC.second);
+    TestFn(TC.first,  L, TC.second, R);
+    TestFn(TC.second, R, TC.first, L);
+  }
+}
+
+int main() {
+  test_comparison_signatures();
+  test_comparisons_simple();
+}
diff --git a/test/std/experimental/filesystem/class.directory_entry/directory_entry.obs/path.pass.cpp b/test/std/experimental/filesystem/class.directory_entry/directory_entry.obs/path.pass.cpp
new file mode 100644
index 000000000000..d228a3d92641
--- /dev/null
+++ b/test/std/experimental/filesystem/class.directory_entry/directory_entry.obs/path.pass.cpp
@@ -0,0 +1,89 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class directory_entry
+
+// const path& path() const noexcept;
+// operator const path&() const noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+namespace fs = std::experimental::filesystem;
+
+void test_path_method() {
+  using namespace fs;
+  const path p("foo/bar/baz.exe");
+  const path p2("abc");
+  {
+    directory_entry nce;
+    const directory_entry e("");
+    static_assert(std::is_same<decltype(e.path()),  const path&>::value, "");
+    static_assert(std::is_same<decltype(nce.path()), const path&>::value, "");
+    static_assert(noexcept(e.path()) && noexcept(nce.path()), "");
+  }
+  {
+    directory_entry e(p);
+    path const& pref = e.path();
+    assert(pref == p);
+    assert(&pref == &e.path());
+    e.assign(p2);
+    assert(pref == p2);
+    assert(&pref == &e.path());
+  }
+}
+
+void test_path_conversion() {
+  using namespace fs;
+  const path p("foo/bar/baz.exe");
+  const path p2("abc");
+  {
+    directory_entry nce;
+    const directory_entry e("");
+    // Check conversions exist
+    static_assert(std::is_convertible<directory_entry&,        path const&>::value, "");
+    static_assert(std::is_convertible<directory_entry const&,  path const&>::value, "");
+    static_assert(std::is_convertible<directory_entry &&,      path const&>::value, "");
+    static_assert(std::is_convertible<directory_entry const&&, path const&>::value, "");
+    // Not convertible to non-const
+    static_assert(!std::is_convertible<directory_entry&,        path&>::value, "");
+    static_assert(!std::is_convertible<directory_entry const&,  path&>::value, "");
+    static_assert(!std::is_convertible<directory_entry &&,      path&>::value, "");
+    static_assert(!std::is_convertible<directory_entry const&&, path&>::value, "");
+    // conversions are noexcept
+    static_assert(noexcept(e.operator fs::path const&()) &&
+                  noexcept(e.operator fs::path const&()), "");
+  }
+  // const
+  {
+    directory_entry const e(p);
+    path const& pref = e;
+    assert(&pref == &e.path());
+  }
+  // non-const
+  {
+    directory_entry e(p);
+    path const& pref = e;
+    assert(&pref == &e.path());
+
+    e.assign(p2);
+    assert(pref == p2);
+    assert(&pref == &e.path());
+  }
+}
+
+int main() {
+  test_path_method();
+  test_path_conversion();
+}
diff --git a/test/std/experimental/filesystem/class.directory_entry/directory_entry.obs/status.pass.cpp b/test/std/experimental/filesystem/class.directory_entry/directory_entry.obs/status.pass.cpp
new file mode 100644
index 000000000000..54c5172ebce4
--- /dev/null
+++ b/test/std/experimental/filesystem/class.directory_entry/directory_entry.obs/status.pass.cpp
@@ -0,0 +1,51 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class directory_entry
+
+// file_status status() const;
+// file_status status(error_code const&) const noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "filesystem_test_helper.hpp"
+
+int main()
+{
+  using namespace fs;
+  {
+    const directory_entry e("foo");
+    std::error_code ec;
+    static_assert(std::is_same<decltype(e.status()), file_status>::value, "");
+    static_assert(std::is_same<decltype(e.status(ec)), file_status>::value, "");
+    static_assert(noexcept(e.status()) == false, "");
+    static_assert(noexcept(e.status(ec)) == true, "");
+  }
+  auto TestFn = [](path const& p) {
+    const directory_entry e(p);
+    std::error_code pec, eec;
+    file_status ps = fs::status(p, pec);
+    file_status es = e.status(eec);
+    assert(ps.type() == es.type());
+    assert(ps.permissions() == es.permissions());
+    assert(pec == eec);
+  };
+  {
+    TestFn(StaticEnv::File);
+    TestFn(StaticEnv::Dir);
+    TestFn(StaticEnv::SymlinkToFile);
+    TestFn(StaticEnv::DNE);
+  }
+}
diff --git a/test/std/experimental/filesystem/class.directory_entry/directory_entry.obs/symlink_status.pass.cpp b/test/std/experimental/filesystem/class.directory_entry/directory_entry.obs/symlink_status.pass.cpp
new file mode 100644
index 000000000000..3a99eb671b44
--- /dev/null
+++ b/test/std/experimental/filesystem/class.directory_entry/directory_entry.obs/symlink_status.pass.cpp
@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class directory_entry
+
+// file_status symlink_status() const;
+// file_status symlink_status(error_code&) const noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "filesystem_test_helper.hpp"
+
+int main() {
+  using namespace fs;
+  {
+    const directory_entry e("foo");
+    std::error_code ec;
+    static_assert(std::is_same<decltype(e.symlink_status()), file_status>::value, "");
+    static_assert(std::is_same<decltype(e.symlink_status(ec)), file_status>::value, "");
+    static_assert(noexcept(e.symlink_status()) == false, "");
+    static_assert(noexcept(e.symlink_status(ec)) == true, "");
+  }
+  auto TestFn = [](path const& p) {
+    const directory_entry e(p);
+    std::error_code pec, eec;
+    file_status ps = fs::symlink_status(p, pec);
+    file_status es = e.symlink_status(eec);
+    assert(ps.type() == es.type());
+    assert(ps.permissions() == es.permissions());
+    assert(pec == eec);
+  };
+  {
+    TestFn(StaticEnv::File);
+    TestFn(StaticEnv::Dir);
+    TestFn(StaticEnv::SymlinkToFile);
+    TestFn(StaticEnv::DNE);
+  }
+}
diff --git a/test/std/experimental/filesystem/class.directory_iterator/directory_iterator.members/copy.pass.cpp b/test/std/experimental/filesystem/class.directory_iterator/directory_iterator.members/copy.pass.cpp
new file mode 100644
index 000000000000..5c4583391e74
--- /dev/null
+++ b/test/std/experimental/filesystem/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
+
+// <experimental/filesystem>
+
+// class directory_iterator
+
+// directory_iterator(directory_iterator const&);
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <set>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+
+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/test/std/experimental/filesystem/class.directory_iterator/directory_iterator.members/copy_assign.pass.cpp b/test/std/experimental/filesystem/class.directory_iterator/directory_iterator.members/copy_assign.pass.cpp
new file mode 100644
index 000000000000..0d5ebf3ebe96
--- /dev/null
+++ b/test/std/experimental/filesystem/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
+
+// <experimental/filesystem>
+
+// class directory_iterator
+
+// directory_iterator& operator=(directory_iterator const&);
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <set>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+
+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/test/std/experimental/filesystem/class.directory_iterator/directory_iterator.members/ctor.pass.cpp b/test/std/experimental/filesystem/class.directory_iterator/directory_iterator.members/ctor.pass.cpp
new file mode 100644
index 000000000000..a6becb1bafaa
--- /dev/null
+++ b/test/std/experimental/filesystem/class.directory_iterator/directory_iterator.members/ctor.pass.cpp
@@ -0,0 +1,246 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/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) noexcept;
+// directory_iterator(const path& p, directory_options options, error_code& ec) noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <set>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+
+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&) noexcept
+    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&) noexcept
+    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 std::experimental::filesystem;
+    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 std::experimental::filesystem;
+    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/test/std/experimental/filesystem/class.directory_iterator/directory_iterator.members/default_ctor.pass.cpp b/test/std/experimental/filesystem/class.directory_iterator/directory_iterator.members/default_ctor.pass.cpp
new file mode 100644
index 000000000000..94ace185a6aa
--- /dev/null
+++ b/test/std/experimental/filesystem/class.directory_iterator/directory_iterator.members/default_ctor.pass.cpp
@@ -0,0 +1,36 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class directory_iterator
+
+// directory_iterator::directory_iterator() noexcept
+
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+namespace fs = std::experimental::filesystem;
+
+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/test/std/experimental/filesystem/class.directory_iterator/directory_iterator.members/increment.pass.cpp b/test/std/experimental/filesystem/class.directory_iterator/directory_iterator.members/increment.pass.cpp
new file mode 100644
index 000000000000..589b4eca7efa
--- /dev/null
+++ b/test/std/experimental/filesystem/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
+
+// <experimental/filesystem>
+
+// class directory_iterator
+
+// directory_iterator& operator++();
+// directory_iterator& increment(error_code& ec) noexcept;
+
+#include <experimental/filesystem>
+#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 std::experimental::filesystem;
+
+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_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/test/std/experimental/filesystem/class.directory_iterator/directory_iterator.members/move.pass.cpp b/test/std/experimental/filesystem/class.directory_iterator/directory_iterator.members/move.pass.cpp
new file mode 100644
index 000000000000..f6c94e18eb0e
--- /dev/null
+++ b/test/std/experimental/filesystem/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
+
+// <experimental/filesystem>
+
+// class directory_iterator
+
+// directory_iterator(directory_iterator&&) noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <set>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+
+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/test/std/experimental/filesystem/class.directory_iterator/directory_iterator.members/move_assign.pass.cpp b/test/std/experimental/filesystem/class.directory_iterator/directory_iterator.members/move_assign.pass.cpp
new file mode 100644
index 000000000000..445f05a3c3e1
--- /dev/null
+++ b/test/std/experimental/filesystem/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
+
+// <experimental/filesystem>
+
+// class directory_iterator
+
+// directory_iterator& operator=(directory_iterator const&);
+
+#include <experimental/filesystem>
+#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 std::experimental::filesystem;
+
+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/test/std/experimental/filesystem/class.directory_iterator/directory_iterator.nonmembers/begin_end.pass.cpp b/test/std/experimental/filesystem/class.directory_iterator/directory_iterator.nonmembers/begin_end.pass.cpp
new file mode 100644
index 000000000000..f93a18452189
--- /dev/null
+++ b/test/std/experimental/filesystem/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
+
+// <experimental/filesystem>
+
+// class directory_iterator
+
+// directory_iterator begin(directory_iterator iter) noexcept;
+// directory_iterator end(directory_iterator iter) noexcept;
+
+#include <experimental/filesystem>
+#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 std::experimental::filesystem;
+
+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/test/std/experimental/filesystem/class.directory_iterator/types.pass.cpp b/test/std/experimental/filesystem/class.directory_iterator/types.pass.cpp
new file mode 100644
index 000000000000..dad278f43d79
--- /dev/null
+++ b/test/std/experimental/filesystem/class.directory_iterator/types.pass.cpp
@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class directory_iterator
+
+// typedef ... value_type;
+// typedef ... difference_type;
+// typedef ... pointer;
+// typedef ... reference;
+// typedef ... iterator_category
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+namespace fs = std::experimental::filesystem;
+
+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);
+}
diff --git a/test/std/experimental/filesystem/class.file_status/file_status.cons.pass.cpp b/test/std/experimental/filesystem/class.file_status/file_status.cons.pass.cpp
new file mode 100644
index 000000000000..585b0bb1dd5e
--- /dev/null
+++ b/test/std/experimental/filesystem/class.file_status/file_status.cons.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
+
+// <experimental/filesystem>
+
+// class file_status
+
+// explicit file_status() noexcept;
+// explicit file_status(file_type, perms prms = perms::unknown) noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_convertible.hpp"
+
+namespace fs = std::experimental::filesystem;
+
+int main() {
+ using namespace fs;
+  // Default ctor
+  {
+    static_assert(std::is_nothrow_default_constructible<file_status>::value,
+                  "The default constructor must be noexcept");
+    static_assert(!test_convertible<file_status>(),
+                  "The default constructor must be explicit");
+    const file_status f;
+    assert(f.type()  == file_type::none);
+    assert(f.permissions() == perms::unknown);
+  }
+
+  // Unary ctor
+  {
+    static_assert(std::is_nothrow_constructible<file_status, file_type>::value,
+                  "This constructor must be noexcept");
+    static_assert(!test_convertible<file_status, file_type>(),
+                 "This constructor must be explicit");
+
+    const file_status f(file_type::not_found);
+    assert(f.type()  == file_type::not_found);
+    assert(f.permissions() == perms::unknown);
+  }
+  // Binary ctor
+  {
+    static_assert(std::is_nothrow_constructible<file_status, file_type, perms>::value,
+                  "This constructor must be noexcept");
+    static_assert(!test_convertible<file_status, file_type, perms>(),
+                  "This constructor must b explicit");
+    const file_status f(file_type::regular, perms::owner_read);
+    assert(f.type()  == file_type::regular);
+    assert(f.permissions() == perms::owner_read);
+  }
+}
diff --git a/test/std/experimental/filesystem/class.file_status/file_status.mods.pass.cpp b/test/std/experimental/filesystem/class.file_status/file_status.mods.pass.cpp
new file mode 100644
index 000000000000..8681b2dc50d6
--- /dev/null
+++ b/test/std/experimental/filesystem/class.file_status/file_status.mods.pass.cpp
@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class file_status
+
+// void type(file_type) noexcept;
+// void permissions(perms) noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+namespace fs = std::experimental::filesystem;
+
+int main() {
+  using namespace fs;
+
+  file_status st;
+
+  // type test
+  {
+    static_assert(noexcept(st.type(file_type::regular)),
+                  "operation must be noexcept");
+    static_assert(std::is_same<decltype(st.type(file_type::regular)), void>::value,
+                 "operation must return void");
+    assert(st.type() != file_type::regular);
+    st.type(file_type::regular);
+    assert(st.type() == file_type::regular);
+  }
+  // permissions test
+  {
+    static_assert(noexcept(st.permissions(perms::owner_read)),
+                  "operation must be noexcept");
+    static_assert(std::is_same<decltype(st.permissions(perms::owner_read)), void>::value,
+                 "operation must return void");
+    assert(st.permissions() != perms::owner_read);
+    st.permissions(perms::owner_read);
+    assert(st.permissions() == perms::owner_read);
+  }
+}
diff --git a/test/std/experimental/filesystem/class.file_status/file_status.obs.pass.cpp b/test/std/experimental/filesystem/class.file_status/file_status.obs.pass.cpp
new file mode 100644
index 000000000000..4113dee453dc
--- /dev/null
+++ b/test/std/experimental/filesystem/class.file_status/file_status.obs.pass.cpp
@@ -0,0 +1,46 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class file_status
+
+// file_type type() const noexcept;
+// perms permissions(p) const noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+namespace fs = std::experimental::filesystem;
+
+int main() {
+  using namespace fs;
+
+  const file_status st(file_type::regular, perms::owner_read);
+
+  // type test
+  {
+    static_assert(noexcept(st.type()),
+                  "operation must be noexcept");
+    static_assert(std::is_same<decltype(st.type()), file_type>::value,
+                 "operation must return file_type");
+    assert(st.type() == file_type::regular);
+  }
+  // permissions test
+  {
+    static_assert(noexcept(st.permissions()),
+                  "operation must be noexcept");
+    static_assert(std::is_same<decltype(st.permissions()), perms>::value,
+                 "operation must return perms");
+    assert(st.permissions() == perms::owner_read);
+  }
+}
diff --git a/test/std/experimental/filesystem/class.filesystem_error/filesystem_error.members.pass.cpp b/test/std/experimental/filesystem/class.filesystem_error/filesystem_error.members.pass.cpp
new file mode 100644
index 000000000000..68b67ed72803
--- /dev/null
+++ b/test/std/experimental/filesystem/class.filesystem_error/filesystem_error.members.pass.cpp
@@ -0,0 +1,103 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class filesystem_error
+
+// filesystem_error(const string& what_arg, error_code ec);
+// filesystem_error(const string& what_arg, const path& p1, error_code ec);
+// filesystem_error(const string& what_arg, const path& p1, const path& p2, error_code ec);
+// const std::error_code& code() const;
+// const char* what() const noexcept;
+// const path& path1() const noexcept;
+// const path& path2() const noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+namespace fs = std::experimental::filesystem;
+
+void test_constructors() {
+  using namespace fs;
+
+  // The string returned by "filesystem_error::what() must contain runtime_error::what()
+  const std::string what_arg = "Hello World";
+  const std::string what_contains = std::runtime_error(what_arg).what();
+  assert(what_contains.find(what_arg) != std::string::npos);
+  auto CheckWhat = [what_contains](filesystem_error const& e) {
+    std::string s = e.what();
+    assert(s.find(what_contains) != std::string::npos);
+  };
+
+  std::error_code ec = std::make_error_code(std::errc::file_exists);
+  const path p1("foo");
+  const path p2("bar");
+
+  // filesystem_error(const string& what_arg, error_code ec);
+  {
+    ASSERT_NOT_NOEXCEPT(filesystem_error(what_arg, ec));
+    filesystem_error e(what_arg, ec);
+    CheckWhat(e);
+    assert(e.code() == ec);
+    assert(e.path1().empty() && e.path2().empty());
+  }
+  // filesystem_error(const string& what_arg, const path&, error_code ec);
+  {
+    ASSERT_NOT_NOEXCEPT(filesystem_error(what_arg, p1, ec));
+    filesystem_error e(what_arg, p1, ec);
+    CheckWhat(e);
+    assert(e.code() == ec);
+    assert(e.path1() == p1);
+    assert(e.path2().empty());
+  }
+  // filesystem_error(const string& what_arg, const path&, const path&, error_code ec);
+  {
+    ASSERT_NOT_NOEXCEPT(filesystem_error(what_arg, p1, p2, ec));
+    filesystem_error e(what_arg, p1, p2, ec);
+    CheckWhat(e);
+    assert(e.code() == ec);
+    assert(e.path1() == p1);
+    assert(e.path2() == p2);
+  }
+}
+
+void test_signatures()
+{
+  using namespace fs;
+  const path p;
+  std::error_code ec;
+  const filesystem_error e("lala", ec);
+  // const path& path1() const noexcept;
+  {
+    ASSERT_SAME_TYPE(path const&, decltype(e.path1()));
+    ASSERT_NOEXCEPT(e.path1());
+  }
+  // const path& path2() const noexcept
+  {
+    ASSERT_SAME_TYPE(path const&, decltype(e.path2()));
+    ASSERT_NOEXCEPT(e.path2());
+  }
+  // const char* what() const noexcept
+  {
+    ASSERT_SAME_TYPE(const char*, decltype(e.what()));
+    ASSERT_NOEXCEPT(e.what());
+  }
+}
+
+int main() {
+  static_assert(std::is_base_of<std::system_error, fs::filesystem_error>::value, "");
+  test_constructors();
+  test_signatures();
+}
diff --git a/test/std/experimental/filesystem/class.path/path.itr/iterator.pass.cpp b/test/std/experimental/filesystem/class.path/path.itr/iterator.pass.cpp
new file mode 100644
index 000000000000..12330ebb5ca8
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/path.itr/iterator.pass.cpp
@@ -0,0 +1,106 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class path
+
+// template <class Source>
+//      path(const Source& source);
+// template <class InputIterator>
+//      path(InputIterator first, InputIterator last);
+
+
+#include <experimental/filesystem>
+#include <iterator>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "filesystem_test_helper.hpp"
+
+namespace fs = std::experimental::filesystem;
+
+
+template <class It>
+std::reverse_iterator<It> mkRev(It it) {
+  return std::reverse_iterator<It>(it);
+}
+
+void checkIteratorConcepts() {
+  using namespace fs;
+  using It = path::iterator;
+  using Traits = std::iterator_traits<It>;
+  ASSERT_SAME_TYPE(Traits::iterator_category, std::bidirectional_iterator_tag);
+  ASSERT_SAME_TYPE(Traits::value_type, path);
+  ASSERT_SAME_TYPE(Traits::pointer,   path const*);
+  ASSERT_SAME_TYPE(Traits::reference, path const&);
+  {
+    It it;
+    ASSERT_SAME_TYPE(It&, decltype(++it));
+    ASSERT_SAME_TYPE(It, decltype(it++));
+    ASSERT_SAME_TYPE(It&, decltype(--it));
+    ASSERT_SAME_TYPE(It, decltype(it--));
+    ASSERT_SAME_TYPE(Traits::reference, decltype(*it));
+    ASSERT_SAME_TYPE(Traits::pointer, decltype(it.operator->()));
+    ASSERT_SAME_TYPE(std::string const&, decltype(it->native()));
+    ASSERT_SAME_TYPE(bool, decltype(it == it));
+    ASSERT_SAME_TYPE(bool, decltype(it != it));
+  }
+  {
+    path const p;
+    ASSERT_SAME_TYPE(It, decltype(p.begin()));
+    ASSERT_SAME_TYPE(It, decltype(p.end()));
+    assert(p.begin() == p.end());
+  }
+}
+
+void checkBeginEndBasic() {
+  using namespace fs;
+  using It = path::iterator;
+  {
+    path const p;
+    ASSERT_SAME_TYPE(It, decltype(p.begin()));
+    ASSERT_SAME_TYPE(It, decltype(p.end()));
+    assert(p.begin() == p.end());
+  }
+  {
+    path const p("foo");
+    It default_constructed;
+    default_constructed = p.begin();
+    assert(default_constructed == p.begin());
+    assert(default_constructed != p.end());
+    default_constructed = p.end();
+    assert(default_constructed == p.end());
+    assert(default_constructed != p.begin());
+  }
+  {
+    path p("//root_name//first_dir////second_dir");
+    const path expect[] = {"//root_name", "/", "first_dir", "second_dir"};
+    assert(checkCollectionsEqual(p.begin(), p.end(), std::begin(expect), std::end(expect)));
+    assert(checkCollectionsEqualBackwards(p.begin(), p.end(), std::begin(expect), std::end(expect)));
+
+  }
+  {
+    path p("////foo/bar/baz///");
+    const path expect[] = {"/", "foo", "bar", "baz", "."};
+    assert(checkCollectionsEqual(p.begin(), p.end(), std::begin(expect), std::end(expect)));
+    assert(checkCollectionsEqualBackwards(p.begin(), p.end(), std::begin(expect), std::end(expect)));
+
+  }
+
+}
+
+int main() {
+  using namespace fs;
+  checkIteratorConcepts();
+  checkBeginEndBasic(); // See path.decompose.pass.cpp for more tests.
+}
diff --git a/test/std/experimental/filesystem/class.path/path.member/path.append.pass.cpp b/test/std/experimental/filesystem/class.path/path.member/path.append.pass.cpp
new file mode 100644
index 000000000000..1118497e06a8
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/path.member/path.append.pass.cpp
@@ -0,0 +1,241 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class path
+
+// path& operator/=(path const&)
+// template <class Source>
+//      path& operator/=(Source const&);
+// template <class Source>
+//      path& append(Source const&);
+// template <class InputIterator>
+//      path& append(InputIterator first, InputIterator last);
+
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "count_new.hpp"
+#include "filesystem_test_helper.hpp"
+
+namespace fs = std::experimental::filesystem;
+
+struct AppendOperatorTestcase {
+  MultiStringType lhs;
+  MultiStringType rhs;
+  MultiStringType expect;
+};
+
+#define S(Str) MKSTR(Str)
+const AppendOperatorTestcase Cases[] =
+    {
+        {S(""),     S(""),      S("")}
+      , {S("p1"),   S("p2"),    S("p1/p2")}
+      , {S("p1/"),  S("p2"),    S("p1/p2")}
+      , {S("p1"),   S("/p2"),   S("p1/p2")}
+      , {S("p1/"),  S("/p2"),   S("p1//p2")}
+      , {S("p1"),   S("\\p2"),  S("p1/\\p2")}
+      , {S("p1\\"), S("p2"),  S("p1\\/p2")}
+      , {S("p1\\"), S("\\p2"),  S("p1\\/\\p2")}
+      , {S("p1"),   S(""),      S("p1")}
+      , {S(""),     S("p2"),    S("p2")}
+    };
+
+
+const AppendOperatorTestcase LongLHSCases[] =
+    {
+        {S("p1"),   S("p2"),    S("p1/p2")}
+      , {S("p1/"),  S("p2"),    S("p1/p2")}
+      , {S("p1"),   S("/p2"),   S("p1/p2")}
+    };
+#undef S
+
+
+// The append operator may need to allocate a temporary buffer before a code_cvt
+// conversion. Test if this allocation occurs by:
+//   1. Create a path, `LHS`, and reserve enough space to append `RHS`.
+//      This prevents `LHS` from allocating during the actual appending.
+//   2. Create a `Source` object `RHS`, which represents a "large" string.
+//      (The string must not trigger the SSO)
+//   3. Append `RHS` to `LHS` and check for the expected allocation behavior.
+template <class CharT>
+void doAppendSourceAllocTest(AppendOperatorTestcase const& TC)
+{
+  using namespace fs;
+  using Ptr = CharT const*;
+  using Str = std::basic_string<CharT>;
+  using InputIter = input_iterator<Ptr>;
+
+  const Ptr L = TC.lhs;
+  Str RShort = (Ptr)TC.rhs;
+  Str EShort = (Ptr)TC.expect;
+  assert(RShort.size() >= 2);
+  CharT c = RShort.back();
+  RShort.append(100, c);
+  EShort.append(100, c);
+  const Ptr R = RShort.data();
+  const Str& E = EShort;
+  std::size_t ReserveSize = E.size() + 3;
+  // basic_string
+  {
+    path LHS(L); PathReserve(LHS, ReserveSize);
+    Str  RHS(R);
+    {
+      DisableAllocationGuard g;
+      LHS /= RHS;
+    }
+    assert(LHS == E);
+  }
+  // CharT*
+  {
+    path LHS(L); PathReserve(LHS, ReserveSize);
+    Ptr RHS(R);
+    {
+      DisableAllocationGuard g;
+      LHS /= RHS;
+    }
+    assert(LHS == E);
+  }
+  {
+    path LHS(L); PathReserve(LHS, ReserveSize);
+    Ptr RHS(R);
+    {
+      DisableAllocationGuard g;
+      LHS.append(RHS, StrEnd(RHS));
+    }
+    assert(LHS == E);
+  }
+  // input iterator - For non-native char types, appends needs to copy the
+  // iterator range into a contigious block of memory before it can perform the
+  // code_cvt conversions.
+  // For "char" no allocations will be performed because no conversion is
+  // required.
+  bool DisableAllocations = std::is_same<CharT, char>::value;
+  {
+    path LHS(L); PathReserve(LHS, ReserveSize);
+    InputIter RHS(R);
+    {
+      RequireAllocationGuard  g; // requires 1 or more allocations occur by default
+      if (DisableAllocations) g.requireExactly(0);
+      LHS /= RHS;
+    }
+    assert(LHS == E);
+  }
+  {
+    path LHS(L); PathReserve(LHS, ReserveSize);
+    InputIter RHS(R);
+    InputIter REnd(StrEnd(R));
+    {
+      RequireAllocationGuard g;
+      if (DisableAllocations) g.requireExactly(0);
+      LHS.append(RHS, REnd);
+    }
+    assert(LHS == E);
+  }
+}
+
+template <class CharT>
+void doAppendSourceTest(AppendOperatorTestcase const& TC)
+{
+  using namespace fs;
+  using Ptr = CharT const*;
+  using Str = std::basic_string<CharT>;
+  using InputIter = input_iterator<Ptr>;
+  const Ptr L = TC.lhs;
+  const Ptr R = TC.rhs;
+  const Ptr E = TC.expect;
+  // basic_string
+  {
+    path LHS(L);
+    Str RHS(R);
+    path& Ref = (LHS /= RHS);
+    assert(LHS == E);
+    assert(&Ref == &LHS);
+  }
+  {
+    path LHS(L);
+    Str RHS(R);
+    path& Ref = LHS.append(RHS);
+    assert(LHS == E);
+    assert(&Ref == &LHS);
+  }
+  // Char*
+  {
+    path LHS(L);
+    Str RHS(R);
+    path& Ref = (LHS /= RHS);
+    assert(LHS == E);
+    assert(&Ref == &LHS);
+  }
+  {
+    path LHS(L);
+    Ptr RHS(R);
+    path& Ref = LHS.append(RHS);
+    assert(LHS == E);
+    assert(&Ref == &LHS);
+  }
+  {
+    path LHS(L);
+    Ptr RHS(R);
+    path& Ref = LHS.append(RHS, StrEnd(RHS));
+    assert(LHS == E);
+    assert(&Ref == &LHS);
+  }
+  // iterators
+  {
+    path LHS(L);
+    InputIter RHS(R);
+    path& Ref = (LHS /= RHS);
+    assert(LHS == E);
+    assert(&Ref == &LHS);
+  }
+  {
+    path LHS(L); InputIter RHS(R);
+    path& Ref = LHS.append(RHS);
+    assert(LHS == E);
+    assert(&Ref == &LHS);
+  }
+  {
+    path LHS(L);
+    InputIter RHS(R);
+    InputIter REnd(StrEnd(R));
+    path& Ref = LHS.append(RHS, REnd);
+    assert(LHS == E);
+    assert(&Ref == &LHS);
+  }
+}
+
+int main()
+{
+  using namespace fs;
+  for (auto const & TC : Cases) {
+    {
+      path LHS((const char*)TC.lhs);
+      path RHS((const char*)TC.rhs);
+      path& Ref = (LHS /= RHS);
+      assert(LHS == (const char*)TC.expect);
+      assert(&Ref == &LHS);
+    }
+    doAppendSourceTest<char>    (TC);
+    doAppendSourceTest<wchar_t> (TC);
+    doAppendSourceTest<char16_t>(TC);
+    doAppendSourceTest<char32_t>(TC);
+  }
+  for (auto const & TC : LongLHSCases) {
+    doAppendSourceAllocTest<char>(TC);
+    doAppendSourceAllocTest<wchar_t>(TC);
+  }
+}
diff --git a/test/std/experimental/filesystem/class.path/path.member/path.assign/copy.pass.cpp b/test/std/experimental/filesystem/class.path/path.member/path.assign/copy.pass.cpp
new file mode 100644
index 000000000000..5c26f8464c12
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/path.member/path.assign/copy.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
+
+// <experimental/filesystem>
+
+// class path
+
+// path& operator=(path const&);
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+namespace fs = std::experimental::filesystem;
+
+int main() {
+  using namespace fs;
+  static_assert(std::is_copy_assignable<path>::value, "");
+  static_assert(!std::is_nothrow_copy_assignable<path>::value, "should not be noexcept");
+  const std::string s("foo");
+  const path p(s);
+  path p2;
+  path& pref = (p2 = p);
+  assert(p.native() == s);
+  assert(p2.native() == s);
+  assert(&pref == &p2);
+}
diff --git a/test/std/experimental/filesystem/class.path/path.member/path.assign/move.pass.cpp b/test/std/experimental/filesystem/class.path/path.member/path.assign/move.pass.cpp
new file mode 100644
index 000000000000..7263424ad252
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/path.member/path.assign/move.pass.cpp
@@ -0,0 +1,43 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class path
+
+// path& operator=(path&&) noexcept
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "count_new.hpp"
+
+namespace fs = std::experimental::filesystem;
+
+int main() {
+  using namespace fs;
+  static_assert(std::is_nothrow_move_assignable<path>::value, "");
+  assert(globalMemCounter.checkOutstandingNewEq(0));
+  const std::string s("we really really really really really really really "
+                      "really really long string so that we allocate");
+  assert(globalMemCounter.checkOutstandingNewEq(1));
+  path p(s);
+  {
+    DisableAllocationGuard g;
+    path p2;
+    path& pref = (p2 = std::move(p));
+    assert(p2.native() == s);
+    assert(p.native() != s); // Testing moved from state
+    assert(&pref == &p2);
+  }
+}
diff --git a/test/std/experimental/filesystem/class.path/path.member/path.assign/source.pass.cpp b/test/std/experimental/filesystem/class.path/path.member/path.assign/source.pass.cpp
new file mode 100644
index 000000000000..4c2d5112d10b
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/path.member/path.assign/source.pass.cpp
@@ -0,0 +1,153 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class path
+
+// template <class Source>
+//      path& operator=(Source const&);
+// template <class Source>
+//      path& assign(Source const&);
+// template <class InputIterator>
+//      path& assign(InputIterator first, InputIterator last);
+
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "count_new.hpp"
+#include "filesystem_test_helper.hpp"
+#include <iostream>
+
+namespace fs = std::experimental::filesystem;
+
+template <class CharT>
+void RunTestCase(MultiStringType const& MS) {
+  using namespace fs;
+  const char* Expect = MS;
+  const CharT* TestPath = MS;
+  const CharT* TestPathEnd = StrEnd(TestPath);
+  const std::size_t Size = TestPathEnd - TestPath;
+  const std::size_t SSize = StrEnd(Expect) - Expect;
+  assert(Size == SSize);
+  //////////////////////////////////////////////////////////////////////////////
+  // basic_string<Char, Traits, Alloc>
+  {
+    const std::basic_string<CharT> S(TestPath);
+    path p; PathReserve(p, S.length() + 1);
+    {
+      // string provides a contigious iterator. No allocation needed.
+      DisableAllocationGuard g;
+      path& pref = (p = S);
+      assert(&pref == &p);
+    }
+    assert(p.native() == Expect);
+    assert(p.string<CharT>() == TestPath);
+    assert(p.string<CharT>() == S);
+  }
+  {
+    const std::basic_string<CharT> S(TestPath);
+    path p; PathReserve(p, S.length() + 1);
+    {
+      DisableAllocationGuard g;
+      path& pref = p.assign(S);
+      assert(&pref == &p);
+    }
+    assert(p.native() == Expect);
+    assert(p.string<CharT>() == TestPath);
+    assert(p.string<CharT>() == S);
+  }
+  //////////////////////////////////////////////////////////////////////////////
+  // Char* pointers
+  {
+    path p; PathReserve(p, Size + 1);
+    {
+      // char* pointers are contigious and can be used with code_cvt directly.
+      // no allocations needed.
+      DisableAllocationGuard g;
+      path& pref = (p = TestPath);
+      assert(&pref == &p);
+    }
+    assert(p.native() == Expect);
+    assert(p.string<CharT>() == TestPath);
+  }
+  {
+    path p; PathReserve(p, Size + 1);
+    {
+      DisableAllocationGuard g;
+      path& pref = p.assign(TestPath);
+      assert(&pref == &p);
+    }
+    assert(p.native() == Expect);
+    assert(p.string<CharT>() == TestPath);
+  }
+  {
+    path p; PathReserve(p, Size + 1);
+    {
+      DisableAllocationGuard g;
+      path& pref = p.assign(TestPath, TestPathEnd);
+      assert(&pref == &p);
+    }
+    assert(p.native() == Expect);
+    assert(p.string<CharT>() == TestPath);
+  }
+  //////////////////////////////////////////////////////////////////////////////
+  // Iterators
+  {
+    using It = input_iterator<const CharT*>;
+    path p; PathReserve(p, Size + 1);
+    It it(TestPath);
+    {
+      // Iterators cannot be used with code_cvt directly. This assignment
+      // may allocate if it's larger than a "short-string".
+      path& pref = (p = it);
+      assert(&pref == &p);
+    }
+    assert(p.native() == Expect);
+    assert(p.string<CharT>() == TestPath);
+  }
+  {
+    using It = input_iterator<const CharT*>;
+    path p; PathReserve(p, Size + 1);
+    It it(TestPath);
+    {
+      path& pref = p.assign(it);
+      assert(&pref == &p);
+    }
+    assert(p.native() == Expect);
+    assert(p.string<CharT>() == TestPath);
+  }
+  {
+    using It = input_iterator<const CharT*>;
+    path p; PathReserve(p, Size + 1);
+    It it(TestPath);
+    It e(TestPathEnd);
+    {
+      path& pref = p.assign(it, e);
+      assert(&pref == &p);
+    }
+    assert(p.native() == Expect);
+    assert(p.string<CharT>() == TestPath);
+  }
+}
+
+int main() {
+  for (auto const& MS : PathList) {
+    RunTestCase<char>(MS);
+    RunTestCase<wchar_t>(MS);
+    RunTestCase<char16_t>(MS);
+    RunTestCase<char32_t>(MS);
+  }
+}
diff --git a/test/std/experimental/filesystem/class.path/path.member/path.compare.pass.cpp b/test/std/experimental/filesystem/class.path/path.member/path.compare.pass.cpp
new file mode 100644
index 000000000000..557c1b24d88f
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/path.member/path.compare.pass.cpp
@@ -0,0 +1,126 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class path
+
+// int compare(path const&) const noexcept;
+// int compare(string_type const&) const;
+// int compare(value_type const*) const;
+//
+// bool operator==(path const&, path const&) noexcept;
+// bool operator!=(path const&, path const&) noexcept;
+// bool operator< (path const&, path const&) noexcept;
+// bool operator<=(path const&, path const&) noexcept;
+// bool operator> (path const&, path const&) noexcept;
+// bool operator>=(path const&, path const&) noexcept;
+//
+// size_t hash_value(path const&) noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <vector>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "count_new.hpp"
+#include "filesystem_test_helper.hpp"
+
+namespace fs = std::experimental::filesystem;
+
+struct PathCompareTest {
+  const char* LHS;
+  const char* RHS;
+  int expect;
+};
+
+#define LONGA "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
+#define LONGB "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
+#define LONGC "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC"
+#define LONGD "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD"
+const PathCompareTest CompareTestCases[] =
+{
+    {"", "",  0},
+    {"a", "", 1},
+    {"", "a", -1},
+    {"a/b/c", "a/b/c", 0},
+    {"b/a/c", "a/b/c", 1},
+    {"a/b/c", "b/a/c", -1},
+    {"a/b", "a/b/c", -1},
+    {"a/b/c", "a/b", 1},
+    {"a/b/", "a/b/.", 0},
+    {"a/b//////", "a/b/////.", 0},
+    {"a/.././b", "a///..//.////b", 0},
+    {"//foo//bar///baz////", "//foo/bar/baz/", 0}, // duplicate separators
+    {"///foo/bar", "/foo/bar", 0}, // "///" is not a root directory
+    {"/foo/bar/", "/foo/bar", 1}, // trailing separator
+    {"//" LONGA "////" LONGB "/" LONGC "///" LONGD, "//" LONGA "/" LONGB "/" LONGC "/" LONGD, 0},
+    { LONGA "/" LONGB "/" LONGC, LONGA "/" LONGB "/" LONGB, 1}
+
+};
+#undef LONGA
+#undef LONGB
+#undef LONGC
+#undef LONGD
+
+int main()
+{
+  using namespace fs;
+  for (auto const & TC : CompareTestCases) {
+    const path p1(TC.LHS);
+    const path p2(TC.RHS);
+    const std::string R(TC.RHS);
+    const int E = TC.expect;
+    { // compare(...) functions
+      DisableAllocationGuard g; // none of these operations should allocate
+
+      // check runtime results
+      int ret1 = p1.compare(p2);
+      int ret2 = p1.compare(R);
+      int ret3 = p1.compare(TC.RHS);
+      assert(ret1 == ret2 && ret1 == ret3);
+      int normalized_ret = ret1 < 0 ? -1 : (ret1 > 0 ? 1 : 0);
+      assert(normalized_ret == E);
+
+      // check signatures
+      ASSERT_NOEXCEPT(p1.compare(p2));
+    }
+    { // comparison operators
+      DisableAllocationGuard g; // none of these operations should allocate
+
+      // Check runtime result
+      assert((p1 == p2) == (E == 0));
+      assert((p1 != p2) == (E != 0));
+      assert((p1 <  p2) == (E <  0));
+      assert((p1 <= p2) == (E <= 0));
+      assert((p1 >  p2) == (E >  0));
+      assert((p1 >= p2) == (E >= 0));
+
+      // Check signatures
+      ASSERT_NOEXCEPT(p1 == p2);
+      ASSERT_NOEXCEPT(p1 != p2);
+      ASSERT_NOEXCEPT(p1 <  p2);
+      ASSERT_NOEXCEPT(p1 <= p2);
+      ASSERT_NOEXCEPT(p1 >  p2);
+      ASSERT_NOEXCEPT(p1 >= p2);
+    }
+    { // check hash values
+      auto h1 = hash_value(p1);
+      auto h2 = hash_value(p2);
+      assert((h1 == h2) == (p1 == p2));
+      // check signature
+      ASSERT_SAME_TYPE(size_t, decltype(hash_value(p1)));
+      ASSERT_NOEXCEPT(hash_value(p1));
+    }
+  }
+}
diff --git a/test/std/experimental/filesystem/class.path/path.member/path.concat.pass.cpp b/test/std/experimental/filesystem/class.path/path.member/path.concat.pass.cpp
new file mode 100644
index 000000000000..6e00afe0b49c
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/path.member/path.concat.pass.cpp
@@ -0,0 +1,277 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class path
+
+// path& operator+=(const path& x);
+// path& operator+=(const string_type& x); // Implemented as Source template
+// path& operator+=(const value_type* x);  // Implemented as Source template
+// path& operator+=(value_type x);
+// template <class Source>
+//   path& operator+=(const Source& x);
+// template <class EcharT>
+//   path& operator+=(EcharT x);
+// template <class Source>
+//   path& concat(const Source& x);
+// template <class InputIterator>
+//   path& concat(InputIterator first, InputIterator last);
+
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "count_new.hpp"
+#include "filesystem_test_helper.hpp"
+
+namespace fs = std::experimental::filesystem;
+
+struct ConcatOperatorTestcase {
+  MultiStringType lhs;
+  MultiStringType rhs;
+  MultiStringType expect;
+};
+
+#define LONGSTR "LONGSTR_LONGSTR_LONGSTR_LONGSTR_LONGSTR_LONGSTR_LONGSTR_LONGSTR_LONGSTR_LONGSTR_LONGSTR_LONGSTR"
+#define S(Str) MKSTR(Str)
+const ConcatOperatorTestcase Cases[] =
+    {
+        {S(""),         S(""),                  S("")}
+      , {S("p1"),       S("p2"),                S("p1p2")}
+      , {S("p1/"),      S("/p2"),               S("p1//p2")}
+      , {S(""),         S("\\foo/bar/baz"),     S("\\foo/bar/baz")}
+      , {S("c:\\foo"),  S(""),                  S("c:\\foo")}
+      , {S(LONGSTR),    S("foo"),               S(LONGSTR "foo")}
+      , {S("abcdefghijklmnopqrstuvwxyz/\\"), S("/\\123456789"), S("abcdefghijklmnopqrstuvwxyz/\\/\\123456789")}
+    };
+const ConcatOperatorTestcase LongLHSCases[] =
+    {
+        {S(""),        S(LONGSTR),     S(LONGSTR)}
+      , {S("p1/"),     S(LONGSTR),      S("p1/" LONGSTR)}
+    };
+const ConcatOperatorTestcase CharTestCases[] =
+    {
+        {S(""),       S("P"), S("P")}
+      , {S("/fooba"), S("r"), S("/foobar")}
+    };
+#undef S
+#undef LONGSTR
+
+// The concat operator may need to allocate a temporary buffer before a code_cvt
+// conversion. Test if this allocation occurs by:
+//   1. Create a path, `LHS`, and reserve enough space to append `RHS`.
+//      This prevents `LHS` from allocating during the actual appending.
+//   2. Create a `Source` object `RHS`, which represents a "large" string.
+//      (The string must not trigger the SSO)
+//   3. Concat `RHS` to `LHS` and check for the expected allocation behavior.
+template <class CharT>
+void doConcatSourceAllocTest(ConcatOperatorTestcase const& TC)
+{
+  using namespace fs;
+  using Ptr = CharT const*;
+  using Str = std::basic_string<CharT>;
+  using InputIter = input_iterator<Ptr>;
+
+  const Ptr L = TC.lhs;
+  const Ptr R = TC.rhs;
+  const Ptr E =  TC.expect;
+  std::size_t ReserveSize = StrLen(E) + 1;
+  // basic_string
+  {
+    path LHS(L); PathReserve(LHS, ReserveSize);
+    Str  RHS(R);
+    {
+      DisableAllocationGuard g;
+      LHS += RHS;
+    }
+    assert(LHS == E);
+  }
+  // CharT*
+  {
+    path LHS(L); PathReserve(LHS, ReserveSize);
+    Ptr RHS(R);
+    {
+      DisableAllocationGuard g;
+      LHS += RHS;
+    }
+    assert(LHS == E);
+  }
+  {
+    path LHS(L); PathReserve(LHS, ReserveSize);
+    Ptr RHS(R);
+    {
+      DisableAllocationGuard g;
+      LHS.concat(RHS, StrEnd(RHS));
+    }
+    assert(LHS == E);
+  }
+  // input iterator - For non-native char types, appends needs to copy the
+  // iterator range into a contigious block of memory before it can perform the
+  // code_cvt conversions.
+  // For "char" no allocations will be performed because no conversion is
+  // required.
+  bool DisableAllocations = std::is_same<CharT, char>::value;
+  {
+    path LHS(L); PathReserve(LHS, ReserveSize);
+    InputIter RHS(R);
+    {
+      RequireAllocationGuard  g; // requires 1 or more allocations occur by default
+      if (DisableAllocations) g.requireExactly(0);
+      LHS += RHS;
+    }
+    assert(LHS == E);
+  }
+  {
+    path LHS(L); PathReserve(LHS, ReserveSize);
+    InputIter RHS(R);
+    InputIter REnd(StrEnd(R));
+    {
+      RequireAllocationGuard g;
+      if (DisableAllocations) g.requireExactly(0);
+      LHS.concat(RHS, REnd);
+    }
+    assert(LHS == E);
+  }
+}
+
+template <class CharT>
+void doConcatSourceTest(ConcatOperatorTestcase const& TC)
+{
+  using namespace fs;
+  using Ptr = CharT const*;
+  using Str = std::basic_string<CharT>;
+  using InputIter = input_iterator<Ptr>;
+  const Ptr L = TC.lhs;
+  const Ptr R = TC.rhs;
+  const Ptr E = TC.expect;
+  // basic_string
+  {
+    path LHS(L);
+    Str RHS(R);
+    path& Ref = (LHS += RHS);
+    assert(LHS == E);
+    assert(&Ref == &LHS);
+  }
+  {
+    path LHS(L);
+    Str RHS(R);
+    path& Ref = LHS.concat(RHS);
+    assert(LHS == E);
+    assert(&Ref == &LHS);
+  }
+  // Char*
+  {
+    path LHS(L);
+    Str RHS(R);
+    path& Ref = (LHS += RHS);
+    assert(LHS == E);
+    assert(&Ref == &LHS);
+  }
+  {
+    path LHS(L);
+    Ptr RHS(R);
+    path& Ref = LHS.concat(RHS);
+    assert(LHS == E);
+    assert(&Ref == &LHS);
+  }
+  {
+    path LHS(L);
+    Ptr RHS(R);
+    path& Ref = LHS.concat(RHS, StrEnd(RHS));
+    assert(LHS == E);
+    assert(&Ref == &LHS);
+  }
+  // iterators
+  {
+    path LHS(L);
+    InputIter RHS(R);
+    path& Ref = (LHS += RHS);
+    assert(LHS == E);
+    assert(&Ref == &LHS);
+  }
+  {
+    path LHS(L); InputIter RHS(R);
+    path& Ref = LHS.concat(RHS);
+    assert(LHS == E);
+    assert(&Ref == &LHS);
+  }
+  {
+    path LHS(L);
+    InputIter RHS(R);
+    InputIter REnd(StrEnd(R));
+    path& Ref = LHS.concat(RHS, REnd);
+    assert(LHS == E);
+    assert(&Ref == &LHS);
+  }
+}
+
+template <class CharT>
+void doConcatECharTest(ConcatOperatorTestcase const& TC)
+{
+  using namespace fs;
+  using Ptr = CharT const*;
+  const Ptr RStr = TC.rhs;
+  assert(StrLen(RStr) == 1);
+  const Ptr L   = TC.lhs;
+  const CharT R = RStr[0];
+  const Ptr E   = TC.expect;
+  {
+    path LHS(L);
+    path& Ref = (LHS += R);
+    assert(LHS == E);
+    assert(&Ref == &LHS);
+  }
+}
+
+int main()
+{
+  using namespace fs;
+  for (auto const & TC : Cases) {
+    {
+      path LHS((const char*)TC.lhs);
+      path RHS((const char*)TC.rhs);
+      path& Ref = (LHS += RHS);
+      assert(LHS == (const char*)TC.expect);
+      assert(&Ref == &LHS);
+    }
+    doConcatSourceTest<char>    (TC);
+    doConcatSourceTest<wchar_t> (TC);
+    doConcatSourceTest<char16_t>(TC);
+    doConcatSourceTest<char32_t>(TC);
+  }
+  for (auto const & TC : LongLHSCases) {
+    // Do path test
+    {
+      path LHS((const char*)TC.lhs);
+      path RHS((const char*)TC.rhs);
+      const char* E = TC.expect;
+      PathReserve(LHS, StrLen(E) + 5);
+      {
+        DisableAllocationGuard g;
+        path& Ref = (LHS += RHS);
+        assert(&Ref == &LHS);
+      }
+      assert(LHS == E);
+    }
+    doConcatSourceAllocTest<char>(TC);
+    doConcatSourceAllocTest<wchar_t>(TC);
+  }
+  for (auto const& TC : CharTestCases) {
+    doConcatECharTest<char>(TC);
+    doConcatECharTest<wchar_t>(TC);
+    doConcatECharTest<char16_t>(TC);
+    doConcatECharTest<char32_t>(TC);
+  }
+}
diff --git a/test/std/experimental/filesystem/class.path/path.member/path.construct/copy.pass.cpp b/test/std/experimental/filesystem/class.path/path.member/path.construct/copy.pass.cpp
new file mode 100644
index 000000000000..67b8a04049ec
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/path.member/path.construct/copy.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
+
+// <experimental/filesystem>
+
+// class path
+
+// path(path const&)
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+namespace fs = std::experimental::filesystem;
+
+int main() {
+  using namespace fs;
+  static_assert(std::is_copy_constructible<path>::value, "");
+  static_assert(!std::is_nothrow_copy_constructible<path>::value, "should not be noexcept");
+  const std::string s("foo");
+  const path p(s);
+  path p2(p);
+  assert(p.native() == s);
+  assert(p2.native() == s);
+}
diff --git a/test/std/experimental/filesystem/class.path/path.member/path.construct/default.pass.cpp b/test/std/experimental/filesystem/class.path/path.member/path.construct/default.pass.cpp
new file mode 100644
index 000000000000..f26504616d50
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/path.member/path.construct/default.pass.cpp
@@ -0,0 +1,31 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class path
+
+// path() noexcept
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+namespace fs = std::experimental::filesystem;
+
+int main() {
+  using namespace fs;
+  static_assert(std::is_nothrow_default_constructible<path>::value, "");
+  const path p;
+  assert(p.empty());
+}
diff --git a/test/std/experimental/filesystem/class.path/path.member/path.construct/move.pass.cpp b/test/std/experimental/filesystem/class.path/path.member/path.construct/move.pass.cpp
new file mode 100644
index 000000000000..b8ac4b307005
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/path.member/path.construct/move.pass.cpp
@@ -0,0 +1,41 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class path
+
+// path(path&&) noexcept
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "count_new.hpp"
+
+namespace fs = std::experimental::filesystem;
+
+int main() {
+  using namespace fs;
+  static_assert(std::is_nothrow_move_constructible<path>::value, "");
+  assert(globalMemCounter.checkOutstandingNewEq(0));
+  const std::string s("we really really really really really really really "
+                      "really really long string so that we allocate");
+  assert(globalMemCounter.checkOutstandingNewEq(1));
+  path p(s);
+  {
+    DisableAllocationGuard g;
+    path p2(std::move(p));
+    assert(p2.native() == s);
+    assert(p.native() != s); // Testing moved from state
+  }
+}
diff --git a/test/std/experimental/filesystem/class.path/path.member/path.construct/source.pass.cpp b/test/std/experimental/filesystem/class.path/path.member/path.construct/source.pass.cpp
new file mode 100644
index 000000000000..d89e7c815efb
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/path.member/path.construct/source.pass.cpp
@@ -0,0 +1,83 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class path
+
+// template <class Source>
+//      path(const Source& source);
+// template <class InputIterator>
+//      path(InputIterator first, InputIterator last);
+
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "min_allocator.h"
+#include "filesystem_test_helper.hpp"
+
+namespace fs = std::experimental::filesystem;
+
+template <class CharT>
+void RunTestCase(MultiStringType const& MS) {
+  using namespace fs;
+  const char* Expect = MS;
+  const CharT* TestPath = MS;
+  const CharT* TestPathEnd = StrEnd(TestPath);
+  const std::size_t Size = TestPathEnd - TestPath;
+  const std::size_t SSize = StrEnd(Expect) - Expect;
+  assert(Size == SSize);
+  // StringTypes
+  {
+    const std::basic_string<CharT> S(TestPath);
+    path p(S);
+    assert(p.native() == Expect);
+    assert(p.string<CharT>() == TestPath);
+    assert(p.string<CharT>() == S);
+  }
+  // Char* pointers
+  {
+    path p(TestPath);
+    assert(p.native() == Expect);
+    assert(p.string<CharT>() == TestPath);
+  }
+  {
+    path p(TestPath, TestPathEnd);
+    assert(p.native() == Expect);
+    assert(p.string<CharT>() == TestPath);
+  }
+  // Iterators
+  {
+    using It = input_iterator<const CharT*>;
+    path p(It{TestPath});
+    assert(p.native() == Expect);
+    assert(p.string<CharT>() == TestPath);
+  }
+  {
+    using It = input_iterator<const CharT*>;
+    path p(It{TestPath}, It{TestPathEnd});
+    assert(p.native() == Expect);
+    assert(p.string<CharT>() == TestPath);
+  }
+}
+
+int main() {
+  for (auto const& MS : PathList) {
+    RunTestCase<char>(MS);
+    RunTestCase<wchar_t>(MS);
+    RunTestCase<char16_t>(MS);
+    RunTestCase<char32_t>(MS);
+  }
+}
diff --git a/test/std/experimental/filesystem/class.path/path.member/path.decompose/path.decompose.pass.cpp b/test/std/experimental/filesystem/class.path/path.member/path.decompose/path.decompose.pass.cpp
new file mode 100644
index 000000000000..4c83481aaf2d
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/path.member/path.decompose/path.decompose.pass.cpp
@@ -0,0 +1,198 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class path
+
+// 8.4.9 path decomposition [path.decompose]
+//------------------------------------------
+// path root_name() const;
+// path root_directory() const;
+// path root_path() const;
+// path relative_path() const;
+// path parent_path() const;
+// path filename() const;
+// path stem() const;
+// path extension() const;
+//-------------------------------
+// 8.4.10 path query [path.query]
+//-------------------------------
+// bool empty() const noexcept;
+// bool has_root_path() const;
+// bool has_root_name() const;
+// bool has_root_directory() const;
+// bool has_relative_path() const;
+// bool has_parent_path() const;
+// bool has_filename() const;
+// bool has_stem() const;
+// bool has_extension() const;
+// bool is_absolute() const;
+// bool is_relative() const;
+//-------------------------------
+// 8.5 path iterators [path.itr]
+//-------------------------------
+// iterator begin() const;
+// iterator end() const;
+
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <vector>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "count_new.hpp"
+#include "filesystem_test_helper.hpp"
+
+template <class It>
+std::reverse_iterator<It> mkRev(It it) {
+  return std::reverse_iterator<It>(it);
+}
+
+
+namespace fs = std::experimental::filesystem;
+struct PathDecomposeTestcase
+{
+    std::string raw;
+    std::vector<std::string> elements;
+    std::string root_path;
+    std::string root_name;
+    std::string root_directory;
+    std::string relative_path;
+    std::string parent_path;
+    std::string filename;
+};
+
+const PathDecomposeTestcase PathTestCases[] =
+  {
+      {"", {}, "", "", "", "", "", ""}
+    , {".", {"."}, "", "", "", ".", "", "."}
+    , {"..", {".."}, "", "", "", "..", "", ".."}
+    , {"foo", {"foo"}, "", "", "", "foo", "", "foo"}
+    , {"/", {"/"}, "/", "", "/", "", "", "/"}
+    , {"/foo", {"/", "foo"}, "/", "", "/", "foo", "/", "foo"}
+    , {"foo/", {"foo", "."}, "", "", "", "foo/", "foo", "."}
+    , {"/foo/", {"/", "foo", "."}, "/", "", "/", "foo/", "/foo", "."}
+    , {"foo/bar", {"foo","bar"}, "",  "", "",  "foo/bar", "foo", "bar"}
+    , {"/foo//bar", {"/","foo","bar"}, "/", "", "/", "foo/bar", "/foo", "bar"}
+    , {"//net", {"//net"}, "//net", "//net", "", "", "", "//net"}
+    , {"//net/foo", {"//net", "/", "foo"}, "//net/", "//net", "/", "foo", "//net/", "foo"}
+    , {"///foo///", {"/", "foo", "."}, "/", "", "/", "foo///", "///foo", "."}
+    , {"///foo///bar", {"/", "foo", "bar"}, "/", "", "/", "foo///bar", "///foo", "bar"}
+    , {"/.", {"/", "."}, "/", "", "/", ".", "/", "."}
+    , {"./", {".", "."}, "", "", "", "./", ".", "."}
+    , {"/..", {"/", ".."}, "/", "", "/", "..", "/", ".."}
+    , {"../", {"..", "."}, "", "", "", "../", "..", "."}
+    , {"foo/.", {"foo", "."}, "", "", "", "foo/.", "foo", "."}
+    , {"foo/..", {"foo", ".."}, "", "", "", "foo/..", "foo", ".."}
+    , {"foo/./", {"foo", ".", "."}, "", "", "", "foo/./", "foo/.", "."}
+    , {"foo/./bar", {"foo", ".", "bar"}, "", "", "", "foo/./bar", "foo/.", "bar"}
+    , {"foo/../", {"foo", "..", "."}, "", "", "", "foo/../", "foo/..", "."}
+    , {"foo/../bar", {"foo", "..", "bar"}, "", "", "", "foo/../bar", "foo/..", "bar"}
+    , {"c:", {"c:"}, "", "", "", "c:", "", "c:"}
+    , {"c:/", {"c:", "."}, "", "", "", "c:/", "c:", "."}
+    , {"c:foo", {"c:foo"}, "", "", "", "c:foo", "", "c:foo"}
+    , {"c:/foo", {"c:", "foo"}, "", "", "", "c:/foo", "c:", "foo"}
+    , {"c:foo/", {"c:foo", "."}, "", "", "", "c:foo/", "c:foo", "."}
+    , {"c:/foo/", {"c:", "foo", "."}, "", "", "", "c:/foo/",  "c:/foo", "."}
+    , {"c:/foo/bar", {"c:", "foo", "bar"}, "", "", "", "c:/foo/bar", "c:/foo", "bar"}
+    , {"prn:", {"prn:"}, "", "", "", "prn:", "", "prn:"}
+    , {"c:\\", {"c:\\"}, "", "", "", "c:\\", "", "c:\\"}
+    , {"c:\\foo", {"c:\\foo"}, "", "", "", "c:\\foo", "", "c:\\foo"}
+    , {"c:foo\\", {"c:foo\\"}, "", "", "", "c:foo\\", "", "c:foo\\"}
+    , {"c:\\foo\\", {"c:\\foo\\"}, "", "", "", "c:\\foo\\", "", "c:\\foo\\"}
+    , {"c:\\foo/",  {"c:\\foo", "."}, "", "", "", "c:\\foo/", "c:\\foo", "."}
+    , {"c:/foo\\bar", {"c:", "foo\\bar"}, "", "", "", "c:/foo\\bar", "c:", "foo\\bar"}
+    , {"//", {"//"}, "//", "//", "", "", "", "//"}
+  };
+
+void decompPathTest()
+{
+  using namespace fs;
+  for (auto const & TC : PathTestCases) {
+    path p(TC.raw);
+    assert(p == TC.raw);
+
+    assert(p.root_path() == TC.root_path);
+    assert(p.has_root_path() !=  TC.root_path.empty());
+
+    assert(p.root_name() == TC.root_name);
+    assert(p.has_root_name() !=  TC.root_name.empty());
+
+    assert(p.root_directory() == TC.root_directory);
+    assert(p.has_root_directory() !=  TC.root_directory.empty());
+
+    assert(p.relative_path() == TC.relative_path);
+    assert(p.has_relative_path() !=  TC.relative_path.empty());
+
+    assert(p.parent_path() == TC.parent_path);
+    assert(p.has_parent_path() !=  TC.parent_path.empty());
+
+    assert(p.filename() == TC.filename);
+    assert(p.has_filename() !=  TC.filename.empty());
+
+    assert(p.is_absolute() == p.has_root_directory());
+    assert(p.is_relative() !=  p.is_absolute());
+
+    assert(checkCollectionsEqual(p.begin(), p.end(),
+                                 TC.elements.begin(), TC.elements.end()));
+    // check backwards
+    assert(checkCollectionsEqual(mkRev(p.end()), mkRev(p.begin()),
+                                 TC.elements.rbegin(), TC.elements.rend()));
+  }
+}
+
+
+struct FilenameDecompTestcase
+{
+  std::string raw;
+  std::string filename;
+  std::string stem;
+  std::string extension;
+};
+
+const FilenameDecompTestcase FilenameTestCases[] =
+{
+    {"", "", "", ""}
+  , {".", ".", ".", ""}
+  , {"..", "..", "..", ""}
+  , {"/", "/", "/", ""}
+  , {"foo", "foo", "foo", ""}
+  , {"/foo/bar.txt", "bar.txt", "bar", ".txt"}
+  , {"foo..txt", "foo..txt", "foo.", ".txt"}
+};
+
+
+void decompFilenameTest()
+{
+  using namespace fs;
+  for (auto const & TC : FilenameTestCases) {
+    path p(TC.raw);
+    assert(p == TC.raw);
+
+    assert(p.filename() == TC.filename);
+    assert(p.has_filename() != TC.filename.empty());
+
+    assert(p.stem() == TC.stem);
+    assert(p.has_stem() != TC.stem.empty());
+
+    assert(p.extension() == TC.extension);
+    assert(p.has_extension() != TC.extension.empty());
+  }
+}
+
+int main()
+{
+  decompPathTest();
+  decompFilenameTest();
+}
diff --git a/test/std/experimental/filesystem/class.path/path.member/path.generic.obs/generic_string_alloc.pass.cpp b/test/std/experimental/filesystem/class.path/path.member/path.generic.obs/generic_string_alloc.pass.cpp
new file mode 100644
index 000000000000..47e94c9a213f
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/path.member/path.generic.obs/generic_string_alloc.pass.cpp
@@ -0,0 +1,57 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class path
+
+// template <class ECharT, class Traits = char_traits<ECharT>,
+//           class Allocator = allocator<ECharT>>
+// basic_string<ECharT, Traits, Allocator>
+// generic_string(const Allocator& a = Allocator()) const;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "count_new.hpp"
+#include "min_allocator.h"
+#include "filesystem_test_helper.hpp"
+
+namespace fs = std::experimental::filesystem;
+
+MultiStringType longString = MKSTR("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ/123456789/abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
+
+
+// generic_string<C, T, A> forwards to string<C, T, A>. Tests for
+// string<C, T, A>() are in "path.native.op/string_alloc.pass.cpp".
+// generic_string is minimally tested here.
+int main()
+{
+  using namespace fs;
+  using CharT = wchar_t;
+  using Traits = std::char_traits<CharT>;
+  using Alloc = malloc_allocator<CharT>;
+  using Str = std::basic_string<CharT, Traits, Alloc>;
+  const wchar_t* expect = longString;
+  const path p((const char*)longString);
+  {
+    DisableAllocationGuard g;
+    Alloc a;
+    Alloc::disable_default_constructor = true;
+    Str s = p.generic_string<wchar_t, Traits, Alloc>(a);
+    assert(s == expect);
+    assert(Alloc::alloc_count > 0);
+    assert(Alloc::outstanding_alloc() == 1);
+  }
+}
diff --git a/test/std/experimental/filesystem/class.path/path.member/path.generic.obs/named_overloads.pass.cpp b/test/std/experimental/filesystem/class.path/path.member/path.generic.obs/named_overloads.pass.cpp
new file mode 100644
index 000000000000..81d06843640d
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/path.member/path.generic.obs/named_overloads.pass.cpp
@@ -0,0 +1,63 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class path
+
+// std::string  generic_string() const;
+// std::wstring generic_wstring() const;
+// std::u8string  generic_u8string() const;
+// std::u16string generic_u16string() const;
+// std::u32string generic_u32string() const;
+
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "count_new.hpp"
+#include "min_allocator.h"
+#include "filesystem_test_helper.hpp"
+
+namespace fs = std::experimental::filesystem;
+
+MultiStringType longString = MKSTR("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ/123456789/abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
+
+int main()
+{
+  using namespace fs;
+  auto const& MS = longString;
+  const char* value = longString;
+  const path p(value);
+  {
+    std::string s = p.generic_string();
+    assert(s == value);
+  }
+  {
+    std::string s = p.generic_u8string();
+    assert(s == (const char*)MS);
+  }
+  {
+    std::wstring s = p.generic_wstring();
+    assert(s == (const wchar_t*)MS);
+  }
+  {
+    std::u16string s = p.generic_u16string();
+    assert(s == (const char16_t*)MS);
+  }
+  {
+    std::u32string s = p.generic_u32string();
+    assert(s == (const char32_t*)MS);
+  }
+}
diff --git a/test/std/experimental/filesystem/class.path/path.member/path.modifiers/clear.pass.cpp b/test/std/experimental/filesystem/class.path/path.member/path.modifiers/clear.pass.cpp
new file mode 100644
index 000000000000..5be934968c46
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/path.member/path.modifiers/clear.pass.cpp
@@ -0,0 +1,45 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class path
+
+// void clear() noexcept
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "count_new.hpp"
+#include "filesystem_test_helper.hpp"
+
+namespace fs = std::experimental::filesystem;
+
+int main() {
+  using namespace fs;
+  const path p("/foo/bar/baz");
+  {
+    path p;
+    ASSERT_NOEXCEPT(p.clear());
+    ASSERT_SAME_TYPE(void, decltype(p.clear()));
+    p.clear();
+    assert(p.empty());
+  }
+  {
+    path p2(p);
+    assert(p == p2);
+    p2.clear();
+    assert(p2.empty());
+  }
+}
diff --git a/test/std/experimental/filesystem/class.path/path.member/path.modifiers/make_preferred.pass.cpp b/test/std/experimental/filesystem/class.path/path.member/path.modifiers/make_preferred.pass.cpp
new file mode 100644
index 000000000000..559538cf0ec4
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/path.member/path.modifiers/make_preferred.pass.cpp
@@ -0,0 +1,55 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class path
+
+// path& make_preferred()
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "count_new.hpp"
+#include "filesystem_test_helper.hpp"
+
+namespace fs = std::experimental::filesystem;
+
+struct MakePreferredTestcase {
+  const char* value;
+};
+
+const MakePreferredTestcase TestCases[] =
+  {
+      {""}
+    , {"hello_world"}
+    , {"/"}
+    , {"/foo/bar/baz/"}
+    , {"\\"}
+    , {"\\foo\\bar\\baz\\"}
+    , {"\\foo\\/bar\\/baz\\"}
+  };
+
+int main()
+{
+  // This operation is an identity operation on linux.
+  using namespace fs;
+  for (auto const & TC : TestCases) {
+    path p(TC.value);
+    assert(p == TC.value);
+    path& Ref = (p.make_preferred());
+    assert(p.native() == TC.value);
+    assert(&Ref == &p);
+  }
+}
diff --git a/test/std/experimental/filesystem/class.path/path.member/path.modifiers/remove_filename.pass.cpp b/test/std/experimental/filesystem/class.path/path.member/path.modifiers/remove_filename.pass.cpp
new file mode 100644
index 000000000000..4ad9084dbf81
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/path.member/path.modifiers/remove_filename.pass.cpp
@@ -0,0 +1,72 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class path
+
+// path& remove_filename()
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "count_new.hpp"
+#include "filesystem_test_helper.hpp"
+
+namespace fs = std::experimental::filesystem;
+
+struct RemoveFilenameTestcase {
+  const char* value;
+  const char* expect;
+};
+
+const RemoveFilenameTestcase TestCases[] =
+  {
+      {"", ""}
+    , {"/", ""}
+    , {"\\", ""}
+    , {".", ""}
+    , {"..", ""}
+    , {"/foo", "/"}
+    , {"/foo/", "/foo"}
+    , {"/foo/.", "/foo"}
+    , {"/foo/..", "/foo"}
+    , {"/foo/////", "/foo"}
+    , {"/foo\\\\", "/"}
+    , {"/foo//\\/", "/foo//\\"}
+    , {"file.txt", ""}
+    , {"bar/../baz/./file.txt", "bar/../baz/."}
+  };
+
+int main()
+{
+  using namespace fs;
+  for (auto const & TC : TestCases) {
+    path const p_orig(TC.value);
+    path p(p_orig);
+    assert(p == TC.value);
+    path& Ref = (p.remove_filename());
+    assert(p == TC.expect);
+    assert(&Ref == &p);
+    {
+      const path parentp = p_orig.parent_path();
+      if (parentp == p_orig.root_name()) {
+
+        assert(p.empty());
+      } else {
+        assert(p == parentp);
+      }
+    }
+  }
+}
diff --git a/test/std/experimental/filesystem/class.path/path.member/path.modifiers/replace_extension.pass.cpp b/test/std/experimental/filesystem/class.path/path.member/path.modifiers/replace_extension.pass.cpp
new file mode 100644
index 000000000000..98f6e9b88ab8
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/path.member/path.modifiers/replace_extension.pass.cpp
@@ -0,0 +1,73 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class path
+
+// path& replace_extension(path const& p = path())
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "count_new.hpp"
+#include "filesystem_test_helper.hpp"
+
+namespace fs = std::experimental::filesystem;
+
+struct ReplaceExtensionTestcase {
+  const char* value;
+  const char* expect;
+  const char* extension;
+};
+
+const ReplaceExtensionTestcase TestCases[] =
+  {
+      {"", "", ""}
+    , {"foo.cpp", "foo", ""}
+    , {"foo.cpp", "foo.", "."}
+    , {"foo..cpp", "foo..txt", "txt"}
+    , {"", ".txt", "txt"}
+    , {"", ".txt", ".txt"}
+    , {"/foo", "/foo.txt", ".txt"}
+    , {"/foo", "/foo.txt", "txt"}
+    , {"/foo.cpp", "/foo.txt", ".txt"}
+    , {"/foo.cpp", "/foo.txt", "txt"}
+  };
+const ReplaceExtensionTestcase NoArgCases[] =
+  {
+      {"", "", ""}
+    , {"foo", "foo", ""}
+    , {"foo.cpp", "foo", ""}
+    , {"foo..cpp", "foo.", ""}
+};
+
+int main()
+{
+  using namespace fs;
+  for (auto const & TC : TestCases) {
+    path p(TC.value);
+    assert(p == TC.value);
+    path& Ref = (p.replace_extension(TC.extension));
+    assert(p == TC.expect);
+    assert(&Ref == &p);
+  }
+  for (auto const& TC : NoArgCases) {
+    path p(TC.value);
+    assert(p == TC.value);
+    path& Ref = (p.replace_extension());
+    assert(p == TC.expect);
+    assert(&Ref == &p);
+  }
+}
diff --git a/test/std/experimental/filesystem/class.path/path.member/path.modifiers/replace_filename.pass.cpp b/test/std/experimental/filesystem/class.path/path.member/path.modifiers/replace_filename.pass.cpp
new file mode 100644
index 000000000000..66c97218c833
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/path.member/path.modifiers/replace_filename.pass.cpp
@@ -0,0 +1,69 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class path
+
+// path& replace_filename()
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "count_new.hpp"
+#include "filesystem_test_helper.hpp"
+
+namespace fs = std::experimental::filesystem;
+
+struct ReplaceFilenameTestcase {
+  const char* value;
+  const char* expect;
+  const char* filename;
+};
+
+const ReplaceFilenameTestcase TestCases[] =
+  {
+      {"/foo", "/bar", "bar"}
+    , {"/foo", "/", ""}
+    , {"foo", "bar", "bar"}
+    , {"/", "bar", "bar"}
+    , {"\\", "bar", "bar"}
+    , {"///", "bar", "bar"}
+    , {"\\\\", "bar", "bar"}
+    , {"\\/\\", "\\/bar", "bar"}
+    , {".", "bar", "bar"}
+    , {"..", "bar", "bar"}
+    , {"/foo\\baz/bong/", "/foo\\baz/bong/bar", "bar"}
+    , {"/foo\\baz/bong", "/foo\\baz/bar", "bar"}
+  };
+
+int main()
+{
+  using namespace fs;
+  for (auto const & TC : TestCases) {
+    path p(TC.value);
+    assert(p == TC.value);
+    path& Ref = (p.replace_filename(TC.filename));
+    assert(p == TC.expect);
+    assert(&Ref == &p);
+    // Tests Effects "as-if": remove_filename() append(filename)
+    {
+      path p2(TC.value);
+      path replace(TC.filename);
+      p2.remove_filename();
+      p2 /= replace;
+      assert(p2 == p);
+    }
+  }
+}
diff --git a/test/std/experimental/filesystem/class.path/path.member/path.modifiers/swap.pass.cpp b/test/std/experimental/filesystem/class.path/path.member/path.modifiers/swap.pass.cpp
new file mode 100644
index 000000000000..04bbe3751a59
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/path.member/path.modifiers/swap.pass.cpp
@@ -0,0 +1,81 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class path
+
+// void swap(path& rhs) noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "count_new.hpp"
+#include "filesystem_test_helper.hpp"
+
+namespace fs = std::experimental::filesystem;
+
+struct SwapTestcase {
+  const char* value1;
+  const char* value2;
+};
+
+#define LONG_STR1 "_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG"
+#define LONG_STR2 "_THIS_IS_LONG2_THIS_IS_LONG2_THIS_IS_LONG2_THIS_IS_LONG2_THIS_IS_LONG2_THIS_IS_LONG2_THIS_IS_LONG2"
+const SwapTestcase TestCases[] =
+  {
+      {"", ""}
+    , {"shortstr", LONG_STR1}
+    , {LONG_STR1, "shortstr"}
+    , {LONG_STR1, LONG_STR2}
+  };
+#undef LONG_STR1
+#undef LONG_STR2
+
+int main()
+{
+  using namespace fs;
+  {
+    path p;
+    ASSERT_NOEXCEPT(p.swap(p));
+    ASSERT_SAME_TYPE(void, decltype(p.swap(p)));
+  }
+  for (auto const & TC : TestCases) {
+    path p1(TC.value1);
+    path p2(TC.value2);
+    {
+      DisableAllocationGuard g;
+      p1.swap(p2);
+    }
+    assert(p1 == TC.value2);
+    assert(p2 == TC.value1);
+    {
+      DisableAllocationGuard g;
+      p1.swap(p2);
+    }
+    assert(p1 == TC.value1);
+    assert(p2 == TC.value2);
+  }
+  // self-swap
+  {
+    const char* Val = "aoeuaoeuaoeuaoeuaoeuaoeuaoeuaoeuaoeu";
+    path p1(Val);
+    assert(p1 == Val);
+    {
+      DisableAllocationGuard g;
+      p1.swap(p1);
+    }
+    assert(p1 == Val);
+  }
+}
diff --git a/test/std/experimental/filesystem/class.path/path.member/path.native.obs/c_str.pass.cpp b/test/std/experimental/filesystem/class.path/path.member/path.native.obs/c_str.pass.cpp
new file mode 100644
index 000000000000..7cf3564bb9b1
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/path.member/path.native.obs/c_str.pass.cpp
@@ -0,0 +1,43 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class path
+
+// const value_type* c_str() const noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "filesystem_test_helper.hpp"
+
+namespace fs = std::experimental::filesystem;
+
+int main()
+{
+  using namespace fs;
+  const char* const value = "hello world";
+  const std::string str_value = value;
+  path p(value);
+  { // Check signature
+    ASSERT_SAME_TYPE(path::value_type const*, decltype(p.c_str()));
+    ASSERT_NOEXCEPT(p.c_str());
+  }
+  {
+    path p(value);
+    assert(p.c_str() == str_value);
+    assert(p.native().c_str() == p.c_str());
+  }
+}
diff --git a/test/std/experimental/filesystem/class.path/path.member/path.native.obs/named_overloads.pass.cpp b/test/std/experimental/filesystem/class.path/path.member/path.native.obs/named_overloads.pass.cpp
new file mode 100644
index 000000000000..2a83fef9f9e6
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/path.member/path.native.obs/named_overloads.pass.cpp
@@ -0,0 +1,63 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class path
+
+// std::string  string() const;
+// std::wstring wstring() const;
+// std::u8string  u8string() const;
+// std::u16string u16string() const;
+// std::u32string u32string() const;
+
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "count_new.hpp"
+#include "min_allocator.h"
+#include "filesystem_test_helper.hpp"
+
+namespace fs = std::experimental::filesystem;
+
+MultiStringType longString = MKSTR("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ/123456789/abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
+
+int main()
+{
+  using namespace fs;
+  auto const& MS = longString;
+  const char* value = longString;
+  const path p(value);
+  {
+    std::string s = p.string();
+    assert(s == value);
+  }
+  {
+    std::string s = p.u8string();
+    assert(s == (const char*)MS);
+  }
+  {
+    std::wstring s = p.wstring();
+    assert(s == (const wchar_t*)MS);
+  }
+  {
+    std::u16string s = p.u16string();
+    assert(s == (const char16_t*)MS);
+  }
+  {
+    std::u32string s = p.u32string();
+    assert(s == (const char32_t*)MS);
+  }
+}
diff --git a/test/std/experimental/filesystem/class.path/path.member/path.native.obs/native.pass.cpp b/test/std/experimental/filesystem/class.path/path.member/path.native.obs/native.pass.cpp
new file mode 100644
index 000000000000..7f8df27faf0a
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/path.member/path.native.obs/native.pass.cpp
@@ -0,0 +1,40 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class path
+
+// const string_type& native() const noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "filesystem_test_helper.hpp"
+
+namespace fs = std::experimental::filesystem;
+
+int main()
+{
+  using namespace fs;
+  const char* const value = "hello world";
+  path p(value);
+  { // Check signature
+    ASSERT_SAME_TYPE(path::string_type const&, decltype(p.native()));
+    ASSERT_NOEXCEPT(p.native());
+  }
+  { // native() is tested elsewhere
+    path p(value);
+    assert(p.native() == value);
+  }
+}
diff --git a/test/std/experimental/filesystem/class.path/path.member/path.native.obs/operator_string.pass.cpp b/test/std/experimental/filesystem/class.path/path.member/path.native.obs/operator_string.pass.cpp
new file mode 100644
index 000000000000..9ef83f989aa5
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/path.member/path.native.obs/operator_string.pass.cpp
@@ -0,0 +1,47 @@
+
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class path
+
+// operator string_type() const;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "filesystem_test_helper.hpp"
+
+namespace fs = std::experimental::filesystem;
+
+int main()
+{
+  using namespace fs;
+  using string_type = path::string_type;
+  const char* const value = "hello world";
+  path p(value);
+  { // Check signature
+    static_assert(std::is_convertible<path, string_type>::value, "");
+    static_assert(std::is_constructible<string_type, path>::value, "");
+    ASSERT_SAME_TYPE(string_type, decltype(p.operator string_type()));
+    ASSERT_NOT_NOEXCEPT(p.operator string_type());
+  }
+  {
+    path p(value);
+    assert(p.native() == value);
+    string_type s = p;
+    assert(s == value);
+    assert(p == value);
+  }
+}
diff --git a/test/std/experimental/filesystem/class.path/path.member/path.native.obs/string_alloc.pass.cpp b/test/std/experimental/filesystem/class.path/path.member/path.native.obs/string_alloc.pass.cpp
new file mode 100644
index 000000000000..e98329735000
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/path.member/path.native.obs/string_alloc.pass.cpp
@@ -0,0 +1,138 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class path
+
+// template <class ECharT, class Traits = char_traits<ECharT>,
+//           class Allocator = allocator<ECharT>>
+// basic_string<ECharT, Traits, Allocator>
+// string(const Allocator& a = Allocator()) const;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "count_new.hpp"
+#include "min_allocator.h"
+#include "filesystem_test_helper.hpp"
+
+namespace fs = std::experimental::filesystem;
+
+// the SSO is always triggered for strings of size 2.
+MultiStringType shortString = MKSTR("a");
+MultiStringType longString = MKSTR("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ/123456789/abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
+
+template <class CharT>
+void doShortStringTest(MultiStringType const& MS) {
+  using namespace fs;
+  using Ptr = CharT const*;
+  using Str = std::basic_string<CharT>;
+  using Alloc = std::allocator<CharT>;
+  Ptr value = MS;
+  const path p((const char*)MS);
+  {
+      DisableAllocationGuard g;
+      Str s = p.string<CharT>();
+      assert(s == value);
+      Str s2 = p.string<CharT>(Alloc{});
+      assert(s2 == value);
+  }
+  using MAlloc = malloc_allocator<CharT>;
+  MAlloc::reset();
+  {
+      using Traits = std::char_traits<CharT>;
+      using AStr = std::basic_string<CharT, Traits, MAlloc>;
+      DisableAllocationGuard g;
+      AStr s = p.string<CharT, Traits, MAlloc>();
+      assert(s == value);
+      assert(MAlloc::alloc_count == 0);
+      assert(MAlloc::outstanding_alloc() == 0);
+  }
+  MAlloc::reset();
+  { // Other allocator - provided copy
+      using Traits = std::char_traits<CharT>;
+      using AStr = std::basic_string<CharT, Traits, MAlloc>;
+      DisableAllocationGuard g;
+      MAlloc a;
+      // don't allow another allocator to be default constructed.
+      MAlloc::disable_default_constructor = true;
+      AStr s = p.string<CharT, Traits, MAlloc>(a);
+      assert(s == value);
+      assert(MAlloc::alloc_count == 0);
+      assert(MAlloc::outstanding_alloc() == 0);
+  }
+  MAlloc::reset();
+}
+
+template <class CharT>
+void doLongStringTest(MultiStringType const& MS) {
+  using namespace fs;
+  using Ptr = CharT const*;
+  using Str = std::basic_string<CharT>;
+  Ptr value = MS;
+  const path p((const char*)MS);
+  { // Default allocator
+      using Alloc = std::allocator<CharT>;
+      Str s = p.string<CharT>();
+      assert(s == value);
+      Str s2 = p.string<CharT>(Alloc{});
+      assert(s2 == value);
+  }
+  using MAlloc = malloc_allocator<CharT>;
+  MAlloc::reset();
+  { // Other allocator - default construct
+      using Traits = std::char_traits<CharT>;
+      using AStr = std::basic_string<CharT, Traits, MAlloc>;
+      DisableAllocationGuard g;
+      AStr s = p.string<CharT, Traits, MAlloc>();
+      assert(s == value);
+      assert(MAlloc::alloc_count > 0);
+      assert(MAlloc::outstanding_alloc() == 1);
+  }
+  MAlloc::reset();
+  { // Other allocator - provided copy
+      using Traits = std::char_traits<CharT>;
+      using AStr = std::basic_string<CharT, Traits, MAlloc>;
+      DisableAllocationGuard g;
+      MAlloc a;
+      // don't allow another allocator to be default constructed.
+      MAlloc::disable_default_constructor = true;
+      AStr s = p.string<CharT, Traits, MAlloc>(a);
+      assert(s == value);
+      assert(MAlloc::alloc_count > 0);
+      assert(MAlloc::outstanding_alloc() == 1);
+  }
+  MAlloc::reset();
+  /////////////////////////////////////////////////////////////////////////////
+}
+
+int main()
+{
+  using namespace fs;
+  {
+    auto const& S = shortString;
+    doShortStringTest<char>(S);
+    doShortStringTest<wchar_t>(S);
+    doShortStringTest<char16_t>(S);
+    doShortStringTest<char32_t>(S);
+  }
+  {
+    auto const& S = longString;
+    doLongStringTest<char>(S);
+    doLongStringTest<wchar_t>(S);
+    doLongStringTest<char16_t>(S);
+    doLongStringTest<char32_t>(S);
+  }
+}
diff --git a/test/std/experimental/filesystem/class.path/path.member/path.query/tested_in_path_decompose.pass.cpp b/test/std/experimental/filesystem/class.path/path.member/path.query/tested_in_path_decompose.pass.cpp
new file mode 100644
index 000000000000..9cf37d4cd537
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/path.member/path.query/tested_in_path_decompose.pass.cpp
@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class path
+
+//-------------------------------
+// 8.4.10 path query [path.query]
+//-------------------------------
+// bool empty() const noexcept;
+// bool has_root_path() const;
+// bool has_root_name() const;
+// bool has_root_directory() const;
+// bool has_relative_path() const;
+// bool has_parent_path() const;
+// bool has_filename() const;
+// bool has_stem() const;
+// bool has_extension() const;
+// bool is_absolute() const;
+// bool is_relative() const;
+
+// tested in path.decompose
+int main() {}
diff --git a/test/std/experimental/filesystem/class.path/path.nonmember/append_op.pass.cpp b/test/std/experimental/filesystem/class.path/path.nonmember/append_op.pass.cpp
new file mode 100644
index 000000000000..58983778446a
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/path.nonmember/append_op.pass.cpp
@@ -0,0 +1,33 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// path operator/(path const&, path const&);
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "filesystem_test_helper.hpp"
+
+namespace fs = std::experimental::filesystem;
+
+// This is mainly tested via the member append functions.
+int main()
+{
+  using namespace fs;
+  path p1("abc");
+  path p2("def");
+  path p3 = p1 / p2;
+  assert(p3 == "abc/def");
+}
diff --git a/test/std/experimental/filesystem/class.path/path.nonmember/comparison_ops_tested_elsewhere.pass.cpp b/test/std/experimental/filesystem/class.path/path.nonmember/comparison_ops_tested_elsewhere.pass.cpp
new file mode 100644
index 000000000000..28867432c61d
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/path.nonmember/comparison_ops_tested_elsewhere.pass.cpp
@@ -0,0 +1,14 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// The comparison operators are tested as part of [path.compare]
+// in class.path/path.members/path.compare.pass.cpp
+int main() {}
diff --git a/test/std/experimental/filesystem/class.path/path.nonmember/hash_value_tested_elswhere.pass.cpp b/test/std/experimental/filesystem/class.path/path.nonmember/hash_value_tested_elswhere.pass.cpp
new file mode 100644
index 000000000000..b03b8008b622
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/path.nonmember/hash_value_tested_elswhere.pass.cpp
@@ -0,0 +1,14 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// The "hash_value" function is tested as part of [path.compare]
+// in class.path/path.members/path.compare.pass.cpp
+int main() {}
diff --git a/test/std/experimental/filesystem/class.path/path.nonmember/path.factory.pass.cpp b/test/std/experimental/filesystem/class.path/path.nonmember/path.factory.pass.cpp
new file mode 100644
index 000000000000..4853994b4950
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/path.nonmember/path.factory.pass.cpp
@@ -0,0 +1,53 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// template <class Source>
+//    path u8path(Source const&);
+// template <class InputIter>
+//   path u8path(InputIter, InputIter);
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "count_new.hpp"
+#include "filesystem_test_helper.hpp"
+
+namespace fs = std::experimental::filesystem;
+
+int main()
+{
+  using namespace fs;
+  const char* In1 = "abcd/efg";
+  const std::string In2(In1);
+  const auto In3 = In2.begin();
+  const auto In3End = In2.end();
+  {
+    path p = fs::u8path(In1);
+    assert(p == In1);
+  }
+  {
+    path p = fs::u8path(In2);
+    assert(p == In1);
+  }
+  {
+    path p = fs::u8path(In3);
+    assert(p == In1);
+  }
+  {
+    path p = fs::u8path(In3, In3End);
+    assert(p == In1);
+  }
+}
diff --git a/test/std/experimental/filesystem/class.path/path.nonmember/path.io.pass.cpp b/test/std/experimental/filesystem/class.path/path.nonmember/path.io.pass.cpp
new file mode 100644
index 000000000000..e8d150f1e39d
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/path.nonmember/path.io.pass.cpp
@@ -0,0 +1,66 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class path
+
+// template <class charT, class traits>
+// basic_ostream<charT, traits>&
+// operator<<(basic_ostream<charT, traits>& os, const path& p);
+//
+// template <class charT, class traits>
+// basic_istream<charT, traits>&
+// operator>>(basic_istream<charT, traits>& is, path& p)
+//
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <sstream>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "count_new.hpp"
+#include "filesystem_test_helper.hpp"
+
+MultiStringType InStr =  MKSTR("abcdefg/\"hijklmnop\"/qrstuvwxyz/123456789");
+MultiStringType OutStr = MKSTR("\"abcdefg/\\\"hijklmnop\\\"/qrstuvwxyz/123456789\"");
+
+template <class CharT>
+void doIOTest() {
+  using namespace fs;
+  using Ptr = const CharT*;
+  using StrStream = std::basic_stringstream<CharT>;
+  const char* const InCStr = InStr;
+  const Ptr E = OutStr;
+  const path p((const char*)InStr);
+  StrStream ss;
+  { // test output
+    auto& ret = (ss << p);
+    assert(ss.str() == E);
+    assert(&ret == &ss);
+  }
+  { // test input
+    path p_in;
+    auto& ret = ss >> p_in;
+    assert(p_in.native() == (const char*)InStr);
+    assert(&ret == &ss);
+  }
+}
+
+
+int main() {
+  doIOTest<char>();
+  doIOTest<wchar_t>();
+  //doIOTest<char16_t>();
+  //doIOTest<char32_t>();
+}
diff --git a/test/std/experimental/filesystem/class.path/path.nonmember/path.io.unicode_bug.pass.cpp b/test/std/experimental/filesystem/class.path/path.nonmember/path.io.unicode_bug.pass.cpp
new file mode 100644
index 000000000000..3a9b48b2669a
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/path.nonmember/path.io.unicode_bug.pass.cpp
@@ -0,0 +1,69 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class path
+
+// template <class charT, class traits>
+// basic_ostream<charT, traits>&
+// operator<<(basic_ostream<charT, traits>& os, const path& p);
+//
+// template <class charT, class traits>
+// basic_istream<charT, traits>&
+// operator>>(basic_istream<charT, traits>& is, path& p)
+//
+
+// TODO(EricWF) This test fails because "std::quoted" fails to compile
+// for char16_t and char32_t types. Combine with path.io.pass.cpp when this
+// passes.
+// XFAIL: *
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <sstream>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "count_new.hpp"
+#include "filesystem_test_helper.hpp"
+
+MultiStringType InStr =  MKSTR("abcdefg/\"hijklmnop\"/qrstuvwxyz/123456789");
+MultiStringType OutStr = MKSTR("\"abcdefg/\\\"hijklmnop\\\"/qrstuvwxyz/123456789\"");
+
+template <class CharT>
+void doIOTest() {
+  using namespace fs;
+  using Ptr = const CharT*;
+  using StrStream = std::basic_stringstream<CharT>;
+  const char* const InCStr = InStr;
+  const Ptr E = OutStr;
+  const path p((const char*)InStr);
+  StrStream ss;
+  { // test output
+    auto& ret = (ss << p);
+    assert(ss.str() == E);
+    assert(&ret == &ss);
+  }
+  { // test input
+    path p_in;
+    auto& ret = ss >> p_in;
+    assert(p_in.native() == (const char*)InStr);
+    assert(&ret == &ss);
+  }
+}
+
+
+int main() {
+  doIOTest<char16_t>();
+  doIOTest<char32_t>();
+}
diff --git a/test/std/experimental/filesystem/class.path/path.nonmember/swap.pass.cpp b/test/std/experimental/filesystem/class.path/path.nonmember/swap.pass.cpp
new file mode 100644
index 000000000000..8d180463a577
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/path.nonmember/swap.pass.cpp
@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// void swap(path& lhs, path& rhs) noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "count_new.hpp"
+#include "filesystem_test_helper.hpp"
+
+namespace fs = std::experimental::filesystem;
+
+// NOTE: this is tested in path.members/path.modifiers via the member swap.
+int main()
+{
+  using namespace fs;
+  const char* value1 = "foo/bar/baz";
+  const char* value2 = "_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG";
+  path p1(value1);
+  path p2(value2);
+  {
+    using namespace std; using namespace fs;
+    ASSERT_NOEXCEPT(swap(p1, p2));
+    ASSERT_SAME_TYPE(void, decltype(swap(p1, p2)));
+  }
+  {
+    DisableAllocationGuard g;
+    using namespace std;
+    using namespace fs;
+    swap(p1, p2);
+    assert(p1.native() == value2);
+    assert(p2.native() == value1);
+    swap(p1, p2);
+    assert(p1.native() == value1);
+    assert(p2.native() == value2);
+  }
+}
diff --git a/test/std/experimental/filesystem/class.path/synop.pass.cpp b/test/std/experimental/filesystem/class.path/synop.pass.cpp
new file mode 100644
index 000000000000..b0a7b5cd65e2
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/synop.pass.cpp
@@ -0,0 +1,39 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class path
+
+// typedef ... value_type;
+// typedef basic_string<value_type> string_type;
+// static constexpr value_type preferred_separator = ...;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+namespace fs = std::experimental::filesystem;
+
+int main() {
+  using namespace fs;
+  ASSERT_SAME_TYPE(path::value_type, char);
+  ASSERT_SAME_TYPE(path::string_type, std::basic_string<path::value_type>);
+  {
+    ASSERT_SAME_TYPE(const path::value_type, decltype(path::preferred_separator));
+    static_assert(path::preferred_separator == '/', "");
+    // Make preferred_separator ODR used by taking it's address.
+    const char* dummy = &path::preferred_separator;
+    ((void)dummy);
+  }
+}
diff --git a/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/copy.pass.cpp b/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/copy.pass.cpp
new file mode 100644
index 000000000000..4dbd599e543a
--- /dev/null
+++ b/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/copy.pass.cpp
@@ -0,0 +1,79 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class recursive_directory_iterator
+
+// recursive_recursive_directory_iterator(recursive_recursive_directory_iterator const&);
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <set>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+
+TEST_SUITE(recursive_directory_iterator_copy_construct_tests)
+
+TEST_CASE(test_constructor_signature)
+{
+    using D = recursive_directory_iterator;
+    static_assert(std::is_copy_constructible<D>::value, "");
+    //static_assert(!std::is_nothrow_copy_constructible<D>::value, "");
+}
+
+TEST_CASE(test_copy_end_iterator)
+{
+    const recursive_directory_iterator endIt;
+    recursive_directory_iterator it(endIt);
+    TEST_CHECK(it == endIt);
+}
+
+TEST_CASE(test_copy_valid_iterator)
+{
+    const path testDir = StaticEnv::Dir;
+    const recursive_directory_iterator endIt{};
+
+    // build 'it' up with "interesting" non-default state so we can test
+    // that it gets copied. We want to get 'it' into a state such that:
+    //  it.options() != directory_options::none
+    //  it.depth() != 0
+    //  it.recursion_pending() != true
+    const directory_options opts = directory_options::skip_permission_denied;
+    recursive_directory_iterator it(testDir, opts);
+    TEST_REQUIRE(it != endIt);
+    while (it.depth() == 0) {
+        ++it;
+        TEST_REQUIRE(it != endIt);
+    }
+    it.disable_recursion_pending();
+    TEST_CHECK(it.options() == opts);
+    TEST_CHECK(it.depth() == 1);
+    TEST_CHECK(it.recursion_pending() == false);
+    const path entry = *it;
+
+    // OPERATION UNDER TEST //
+    const recursive_directory_iterator it2(it);
+    // ------------------- //
+
+    TEST_REQUIRE(it2 == it);
+    TEST_CHECK(*it2 == entry);
+    TEST_CHECK(it2.depth() == 1);
+    TEST_CHECK(it2.recursion_pending() == false);
+    TEST_CHECK(it != endIt);
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/copy_assign.pass.cpp b/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/copy_assign.pass.cpp
new file mode 100644
index 000000000000..3e9257eac8fa
--- /dev/null
+++ b/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/copy_assign.pass.cpp
@@ -0,0 +1,158 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class recursive_directory_iterator
+
+// recursive_directory_iterator& operator=(recursive_directory_iterator const&);
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <set>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+
+TEST_SUITE(recursive_directory_iterator_copy_assign_tests)
+
+recursive_directory_iterator createInterestingIterator()
+    // Create an "interesting" iterator where all fields are
+    // in a non-default state. The returned 'it' is in a
+    // state such that:
+    //   it.options() == directory_options::skip_permission_denied
+    //   it.depth() == 1
+    //   it.recursion_pending() == true
+{
+    const path testDir = StaticEnv::Dir;
+    const recursive_directory_iterator endIt;
+    recursive_directory_iterator it(testDir,
+                                    directory_options::skip_permission_denied);
+    TEST_ASSERT(it != endIt);
+    while (it.depth() != 1) {
+        ++it;
+        TEST_ASSERT(it != endIt);
+    }
+    TEST_ASSERT(it.depth() == 1);
+    it.disable_recursion_pending();
+    return it;
+}
+
+
+recursive_directory_iterator createDifferentInterestingIterator()
+    // Create an "interesting" iterator where all fields are
+    // in a non-default state. The returned 'it' is in a
+    // state such that:
+    //   it.options() == directory_options::follow_directory_symlink
+    //   it.depth() == 2
+    //   it.recursion_pending() == false
+{
+    const path testDir = StaticEnv::Dir;
+    const recursive_directory_iterator endIt;
+    recursive_directory_iterator it(testDir,
+                                    directory_options::follow_directory_symlink);
+    TEST_ASSERT(it != endIt);
+    while (it.depth() != 2) {
+        ++it;
+        TEST_ASSERT(it != endIt);
+    }
+    TEST_ASSERT(it.depth() == 2);
+    return it;
+}
+
+TEST_CASE(test_assignment_signature) {
+    using D = recursive_directory_iterator;
+    static_assert(std::is_copy_assignable<D>::value, "");
+}
+
+TEST_CASE(test_copy_to_end_iterator)
+{
+    const recursive_directory_iterator endIt;
+
+    const recursive_directory_iterator from = createInterestingIterator();
+    const path entry = *from;
+
+    recursive_directory_iterator to;
+    to = from;
+    TEST_REQUIRE(to == from);
+    TEST_CHECK(*to == entry);
+    TEST_CHECK(to.options() == from.options());
+    TEST_CHECK(to.depth() == from.depth());
+    TEST_CHECK(to.recursion_pending() == from.recursion_pending());
+}
+
+
+TEST_CASE(test_copy_from_end_iterator)
+{
+    const recursive_directory_iterator from;
+    recursive_directory_iterator to = createInterestingIterator();
+
+    to = from;
+    TEST_REQUIRE(to == from);
+    TEST_CHECK(to == recursive_directory_iterator{});
+}
+
+TEST_CASE(test_copy_valid_iterator)
+{
+    const recursive_directory_iterator endIt;
+
+    const recursive_directory_iterator it = createInterestingIterator();
+    const path entry = *it;
+
+    recursive_directory_iterator it2 = createDifferentInterestingIterator();
+    TEST_REQUIRE(it2                   != it);
+    TEST_CHECK(it2.options()           != it.options());
+    TEST_CHECK(it2.depth()             != it.depth());
+    TEST_CHECK(it2.recursion_pending() != it.recursion_pending());
+    TEST_CHECK(*it2                    != entry);
+
+    it2 = it;
+    TEST_REQUIRE(it2                   == it);
+    TEST_CHECK(it2.options()           == it.options());
+    TEST_CHECK(it2.depth()             == it.depth());
+    TEST_CHECK(it2.recursion_pending() == it.recursion_pending());
+    TEST_CHECK(*it2                    == entry);
+}
+
+TEST_CASE(test_returns_reference_to_self)
+{
+    const recursive_directory_iterator it;
+    recursive_directory_iterator it2;
+    recursive_directory_iterator& ref = (it2 = it);
+    TEST_CHECK(&ref == &it2);
+}
+
+TEST_CASE(test_self_copy)
+{
+    // Create two non-equal iterators that have exactly the same state.
+    recursive_directory_iterator it = createInterestingIterator();
+    recursive_directory_iterator it2 = createInterestingIterator();
+    TEST_CHECK(it != it2);
+    TEST_CHECK(it2.options()           == it.options());
+    TEST_CHECK(it2.depth()             == it.depth());
+    TEST_CHECK(it2.recursion_pending() == it.recursion_pending());
+    TEST_CHECK(*it2 == *it);
+
+    // perform a self-copy and check that the state still matches the
+    // other unmodified iterator.
+    recursive_directory_iterator const& cit = it;
+    it = cit;
+    TEST_CHECK(it2.options()           == it.options());
+    TEST_CHECK(it2.depth()             == it.depth());
+    TEST_CHECK(it2.recursion_pending() == it.recursion_pending());
+    TEST_CHECK(*it2 == *it);
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/ctor.pass.cpp b/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/ctor.pass.cpp
new file mode 100644
index 000000000000..1cddccd0d724
--- /dev/null
+++ b/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/ctor.pass.cpp
@@ -0,0 +1,240 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class directory_iterator
+
+//
+// explicit recursive_directory_iterator(const path& p);
+// recursive_directory_iterator(const path& p, directory_options options);
+// recursive_directory_iterator(const path& p, error_code& ec) noexcept;
+// recursive_directory_iterator(const path& p, directory_options options, error_code& ec) noexcept;
+
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <set>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+
+using RDI = recursive_directory_iterator;
+
+TEST_SUITE(recursive_directory_iterator_constructor_tests)
+
+TEST_CASE(test_constructor_signatures)
+{
+    using D = recursive_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&) noexcept
+    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&) noexcept
+    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 RDI endIt;
+
+    const path testPaths[] = { StaticEnv::DNE, StaticEnv::BadSymlink };
+    for (path const& testPath : testPaths)
+    {
+        {
+            RDI it(testPath, ec);
+            TEST_CHECK(ec);
+            TEST_CHECK(it == endIt);
+        }
+        {
+            RDI it(testPath, opts, ec);
+            TEST_CHECK(ec);
+            TEST_CHECK(it == endIt);
+        }
+        {
+            TEST_CHECK_THROW(filesystem_error, RDI(testPath));
+            TEST_CHECK_THROW(filesystem_error, RDI(testPath, opts));
+        }
+    }
+}
+
+TEST_CASE(access_denied_test_case)
+{
+    using namespace std::experimental::filesystem;
+    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
+    RDI it(testDir);
+    TEST_REQUIRE(it != RDI{});
+
+    // 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;
+        RDI it(testDir, ec);
+        TEST_REQUIRE(ec);
+        TEST_CHECK(it == RDI{});
+    }
+    // Check that construction does not report an error when
+    // 'skip_permissions_denied' is given.
+    {
+        std::error_code ec;
+        RDI it(testDir, directory_options::skip_permission_denied, ec);
+        TEST_REQUIRE(!ec);
+        TEST_CHECK(it == RDI{});
+    }
+}
+
+
+TEST_CASE(access_denied_to_file_test_case)
+{
+    using namespace std::experimental::filesystem;
+    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;
+        RDI it(testFile, ec);
+        TEST_REQUIRE(ec);
+        TEST_CHECK(it == RDI{});
+    }
+    // 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;
+        RDI it(testFile, directory_options::skip_permission_denied, ec);
+        TEST_REQUIRE(ec);
+        TEST_CHECK(it == RDI{});
+    }
+}
+
+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 RDI endIt;
+    {
+        std::error_code ec;
+        RDI it(testDir, ec);
+        TEST_CHECK(!ec);
+        TEST_CHECK(it == endIt);
+    }
+    {
+        RDI 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 RDI endIt{};
+
+    {
+        std::error_code ec;
+        RDI it(testDir, ec);
+        TEST_REQUIRE(!ec);
+        TEST_CHECK(it != endIt);
+        TEST_CHECK(dir_contents.count(*it));
+    }
+    {
+        RDI 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 RDI endIt{};
+    {
+        std::error_code ec;
+        RDI it(testFile, ec);
+        TEST_REQUIRE(ec);
+        TEST_CHECK(it == endIt);
+    }
+    {
+        TEST_CHECK_THROW(filesystem_error, RDI(testFile));
+    }
+}
+
+TEST_CASE(test_options_post_conditions)
+{
+    const path goodDir = StaticEnv::Dir;
+    const path badDir = StaticEnv::DNE;
+
+    {
+        std::error_code ec;
+
+        RDI it1(goodDir, ec);
+        TEST_REQUIRE(!ec);
+        TEST_CHECK(it1.options() == directory_options::none);
+
+        RDI it2(badDir, ec);
+        TEST_REQUIRE(ec);
+        TEST_REQUIRE(it2 == RDI{});
+    }
+    {
+        std::error_code ec;
+        const directory_options opts = directory_options::skip_permission_denied;
+
+        RDI it1(goodDir, opts, ec);
+        TEST_REQUIRE(!ec);
+        TEST_CHECK(it1.options() == opts);
+
+        RDI it2(badDir, opts, ec);
+        TEST_REQUIRE(ec);
+        TEST_REQUIRE(it2 == RDI{});
+    }
+    {
+        RDI it(goodDir);
+        TEST_CHECK(it.options() == directory_options::none);
+    }
+    {
+        const directory_options opts = directory_options::follow_directory_symlink;
+        RDI it(goodDir, opts);
+        TEST_CHECK(it.options() == opts);
+    }
+}
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/depth.pass.cpp b/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/depth.pass.cpp
new file mode 100644
index 000000000000..676e6f27c886
--- /dev/null
+++ b/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/depth.pass.cpp
@@ -0,0 +1,66 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class recursive_directory_iterator
+
+// int depth() const
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <set>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+
+TEST_SUITE(recursive_directory_iterator_depth_tests)
+
+TEST_CASE(test_depth)
+{
+    const path testDir = StaticEnv::Dir;
+    const path DirDepth1 = StaticEnv::Dir2;
+    const path DirDepth2 = StaticEnv::Dir3;
+    const recursive_directory_iterator endIt{};
+
+    std::error_code ec;
+    recursive_directory_iterator it(testDir, ec);
+    TEST_REQUIRE(!ec);
+    TEST_CHECK(it.depth() == 0);
+
+    bool seen_d1, seen_d2;
+    seen_d1 = seen_d2 = false;
+
+    while (it != endIt) {
+        const path entry = *it;
+        const path parent = entry.parent_path();
+        if (parent == testDir) {
+            TEST_CHECK(it.depth() == 0);
+        } else if (parent == DirDepth1) {
+            TEST_CHECK(it.depth() == 1);
+            seen_d1 = true;
+        } else if (parent == DirDepth2) {
+            TEST_CHECK(it.depth() == 2);
+            seen_d2 = true;
+        } else {
+            TEST_CHECK(!"Unexpected depth while iterating over static env");
+        }
+        ++it;
+    }
+    TEST_REQUIRE(seen_d1 && seen_d2);
+    TEST_CHECK(it == endIt);
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/disable_recursion_pending.pass.cpp b/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/disable_recursion_pending.pass.cpp
new file mode 100644
index 000000000000..387c6145b6a5
--- /dev/null
+++ b/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/disable_recursion_pending.pass.cpp
@@ -0,0 +1,43 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class recursive_directory_iterator
+
+// void disable_recursion_pending();
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <set>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+
+TEST_SUITE(recursive_directory_iterator_disable_recursion_pending_tests)
+
+// NOTE: The main semantics of disable_recursion_pending are tested
+// in the 'recursion_pending()' tests.
+TEST_CASE(basic_test)
+{
+    recursive_directory_iterator it(StaticEnv::Dir);
+    TEST_REQUIRE(it.recursion_pending() == true);
+    it.disable_recursion_pending();
+    TEST_CHECK(it.recursion_pending() == false);
+    it.disable_recursion_pending();
+    TEST_CHECK(it.recursion_pending() == false);
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/increment.pass.cpp b/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/increment.pass.cpp
new file mode 100644
index 000000000000..e67fc2f20f6e
--- /dev/null
+++ b/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/increment.pass.cpp
@@ -0,0 +1,240 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class recursive_directory_iterator
+
+// recursive_directory_iterator& operator++();
+// recursive_directory_iterator& increment(error_code& ec) noexcept;
+
+#include <experimental/filesystem>
+#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 std::experimental::filesystem;
+
+TEST_SUITE(recursive_directory_iterator_increment_tests)
+
+TEST_CASE(test_increment_signatures)
+{
+    using D = recursive_directory_iterator;
+    recursive_directory_iterator d; ((void)d);
+    std::error_code ec; ((void)ec);
+
+    ASSERT_SAME_TYPE(decltype(++d), recursive_directory_iterator&);
+    ASSERT_NOT_NOEXCEPT(++d);
+
+    ASSERT_SAME_TYPE(decltype(d.increment(ec)), recursive_directory_iterator&);
+    ASSERT_NOEXCEPT(d.increment(ec));
+}
+
+TEST_CASE(test_prefix_increment)
+{
+    const path testDir = StaticEnv::Dir;
+    const std::set<path> dir_contents(std::begin(StaticEnv::RecDirIterationList),
+                                      std::end(  StaticEnv::RecDirIterationList));
+    const recursive_directory_iterator endIt{};
+
+    std::error_code ec;
+    recursive_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);
+        recursive_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::RecDirIterationList),
+                                      std::end(  StaticEnv::RecDirIterationList));
+    const recursive_directory_iterator endIt{};
+
+    std::error_code ec;
+    recursive_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::RecDirIterationList),
+                                      std::end(  StaticEnv::RecDirIterationList));
+    const recursive_directory_iterator endIt{};
+
+    std::error_code ec;
+    recursive_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);
+        recursive_directory_iterator& it_ref = it.increment(ec);
+        TEST_REQUIRE(!ec);
+        TEST_CHECK(&it_ref == &it);
+    }
+
+    TEST_CHECK(it == endIt);
+}
+
+TEST_CASE(test_follow_symlinks)
+{
+    const path testDir = StaticEnv::Dir;
+    auto const& IterList = StaticEnv::RecDirFollowSymlinksIterationList;
+
+    const std::set<path> dir_contents(std::begin(IterList), std::end(IterList));
+    const recursive_directory_iterator endIt{};
+
+    std::error_code ec;
+    recursive_directory_iterator it(testDir,
+                              directory_options::follow_directory_symlink, 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);
+        recursive_directory_iterator& it_ref = it.increment(ec);
+        TEST_REQUIRE(!ec);
+        TEST_CHECK(&it_ref == &it);
+    }
+    TEST_CHECK(it == endIt);
+}
+
+TEST_CASE(access_denied_on_recursion_test_case)
+{
+    using namespace std::experimental::filesystem;
+    scoped_test_env env;
+    const path testFiles[] = {
+        env.create_dir("dir1"),
+        env.create_dir("dir1/dir2"),
+        env.create_file("dir1/dir2/file1"),
+        env.create_file("dir1/file2")
+    };
+    const path startDir = testFiles[0];
+    const path permDeniedDir = testFiles[1];
+    const path otherFile = testFiles[3];
+    auto SkipEPerm = directory_options::skip_permission_denied;
+
+    // Change the permissions so we can no longer iterate
+    permissions(permDeniedDir, perms::none);
+
+    const recursive_directory_iterator endIt;
+
+    // Test that recursion resulting in a "EACCESS" error is not ignored
+    // by default.
+    {
+        std::error_code ec = GetTestEC();
+        recursive_directory_iterator it(startDir, ec);
+        TEST_REQUIRE(ec != GetTestEC());
+        TEST_REQUIRE(!ec);
+        while (it != endIt && it->path() != permDeniedDir)
+            ++it;
+        TEST_REQUIRE(it != endIt);
+        TEST_REQUIRE(*it == permDeniedDir);
+
+        it.increment(ec);
+        TEST_CHECK(ec);
+        TEST_CHECK(it == endIt);
+    }
+    // Same as obove but test operator++().
+    {
+        std::error_code ec = GetTestEC();
+        recursive_directory_iterator it(startDir, ec);
+        TEST_REQUIRE(!ec);
+        while (it != endIt && it->path() != permDeniedDir)
+            ++it;
+        TEST_REQUIRE(it != endIt);
+        TEST_REQUIRE(*it == permDeniedDir);
+
+        TEST_REQUIRE_THROW(filesystem_error, ++it);
+    }
+    // Test that recursion resulting in a "EACCESS" error is ignored when the
+    // correct options are given to the constructor.
+    {
+        std::error_code ec = GetTestEC();
+        recursive_directory_iterator it(startDir, SkipEPerm, ec);
+        TEST_REQUIRE(!ec);
+        TEST_REQUIRE(it != endIt);
+
+        bool seenOtherFile = false;
+        if (*it == otherFile) {
+            ++it;
+            seenOtherFile = true;
+            TEST_REQUIRE (it != endIt);
+        }
+        TEST_REQUIRE(*it == permDeniedDir);
+
+        ec = GetTestEC();
+        it.increment(ec);
+        TEST_REQUIRE(!ec);
+
+        if (seenOtherFile) {
+            TEST_CHECK(it == endIt);
+        } else {
+            TEST_CHECK(it != endIt);
+            TEST_CHECK(*it == otherFile);
+        }
+    }
+    // Test that construction resulting in a "EACCESS" error is not ignored
+    // by default.
+    {
+        std::error_code ec;
+        recursive_directory_iterator it(permDeniedDir, ec);
+        TEST_REQUIRE(ec);
+        TEST_REQUIRE(it == endIt);
+    }
+    // Same as obove but testing the throwing constructors
+    {
+        TEST_REQUIRE_THROW(filesystem_error,
+                           recursive_directory_iterator(permDeniedDir));
+    }
+    // Test that construction resulting in a "EACCESS" error constructs the
+    // end iterator when the correct options are given.
+    {
+        std::error_code ec = GetTestEC();
+        recursive_directory_iterator it(permDeniedDir, SkipEPerm, ec);
+        TEST_REQUIRE(!ec);
+        TEST_REQUIRE(it == endIt);
+    }
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/move.pass.cpp b/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/move.pass.cpp
new file mode 100644
index 000000000000..16dde66d216e
--- /dev/null
+++ b/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/move.pass.cpp
@@ -0,0 +1,80 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class recursive_directory_iterator
+
+// recursive_directory_iterator(recursive_directory_iterator&&) noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <set>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+
+TEST_SUITE(recursive_directory_iterator_move_construct_tests)
+
+TEST_CASE(test_constructor_signature)
+{
+    using D = recursive_directory_iterator;
+    static_assert(std::is_nothrow_move_constructible<D>::value, "");
+}
+
+TEST_CASE(test_move_end_iterator)
+{
+    const recursive_directory_iterator endIt;
+    recursive_directory_iterator endIt2{};
+
+    recursive_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 recursive_directory_iterator endIt{};
+
+    // build 'it' up with "interesting" non-default state so we can test
+    // that it gets copied. We want to get 'it' into a state such that:
+    //  it.options() != directory_options::none
+    //  it.depth() != 0
+    //  it.recursion_pending() != true
+    const directory_options opts = directory_options::skip_permission_denied;
+    recursive_directory_iterator it(testDir, opts);
+    TEST_REQUIRE(it != endIt);
+    while (it.depth() == 0) {
+        ++it;
+        TEST_REQUIRE(it != endIt);
+    }
+    it.disable_recursion_pending();
+    TEST_CHECK(it.options() == opts);
+    TEST_CHECK(it.depth() == 1);
+    TEST_CHECK(it.recursion_pending() == false);
+    const path entry = *it;
+
+    // OPERATION UNDER TEST //
+    const recursive_directory_iterator it2(std::move(it));
+    // ------------------- //
+
+    TEST_REQUIRE(it2 != endIt);
+    TEST_CHECK(*it2 == entry);
+    TEST_CHECK(it2.depth() == 1);
+    TEST_CHECK(it2.recursion_pending() == false);
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/move_assign.pass.cpp b/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/move_assign.pass.cpp
new file mode 100644
index 000000000000..915d00267a82
--- /dev/null
+++ b/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/move_assign.pass.cpp
@@ -0,0 +1,169 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class recursive_directory_iterator
+
+// recursive_directory_iterator& operator=(recursive_directory_iterator const&);
+
+#include <experimental/filesystem>
+#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 std::experimental::filesystem;
+
+TEST_SUITE(recursive_directory_iterator_move_assign_tests)
+
+recursive_directory_iterator createInterestingIterator()
+    // Create an "interesting" iterator where all fields are
+    // in a non-default state. The returned 'it' is in a
+    // state such that:
+    //   it.options() == directory_options::skip_permission_denied
+    //   it.depth() == 1
+    //   it.recursion_pending() == true
+{
+    const path testDir = StaticEnv::Dir;
+    const recursive_directory_iterator endIt;
+    recursive_directory_iterator it(testDir,
+                                    directory_options::skip_permission_denied);
+    TEST_ASSERT(it != endIt);
+    while (it.depth() != 1) {
+        ++it;
+        TEST_ASSERT(it != endIt);
+    }
+    TEST_ASSERT(it.depth() == 1);
+    it.disable_recursion_pending();
+    return it;
+}
+
+recursive_directory_iterator createDifferentInterestingIterator()
+    // Create an "interesting" iterator where all fields are
+    // in a non-default state. The returned 'it' is in a
+    // state such that:
+    //   it.options() == directory_options::follow_directory_symlink
+    //   it.depth() == 2
+    //   it.recursion_pending() == false
+{
+    const path testDir = StaticEnv::Dir;
+    const recursive_directory_iterator endIt;
+    recursive_directory_iterator it(testDir,
+                                    directory_options::follow_directory_symlink);
+    TEST_ASSERT(it != endIt);
+    while (it.depth() != 2) {
+        ++it;
+        TEST_ASSERT(it != endIt);
+    }
+    TEST_ASSERT(it.depth() == 2);
+    return it;
+}
+
+
+TEST_CASE(test_assignment_signature)
+{
+    using D = recursive_directory_iterator;
+    static_assert(std::is_nothrow_move_assignable<D>::value, "");
+}
+
+
+TEST_CASE(test_move_to_end_iterator)
+{
+    const recursive_directory_iterator endIt;
+
+    recursive_directory_iterator from = createInterestingIterator();
+    const recursive_directory_iterator from_copy(from);
+    const path entry = *from;
+
+    recursive_directory_iterator to;
+    to = std::move(from);
+    TEST_REQUIRE(to != endIt);
+    TEST_CHECK(*to == entry);
+    TEST_CHECK(to.options() == from_copy.options());
+    TEST_CHECK(to.depth() == from_copy.depth());
+    TEST_CHECK(to.recursion_pending() == from_copy.recursion_pending());
+    TEST_CHECK(from == endIt || from == to);
+}
+
+
+TEST_CASE(test_move_from_end_iterator)
+{
+    recursive_directory_iterator from;
+    recursive_directory_iterator to = createInterestingIterator();
+
+    to = std::move(from);
+    TEST_REQUIRE(to == from);
+    TEST_CHECK(to == recursive_directory_iterator{});
+}
+
+TEST_CASE(test_move_valid_iterator)
+{
+    const recursive_directory_iterator endIt;
+
+    recursive_directory_iterator it = createInterestingIterator();
+    const recursive_directory_iterator it_copy(it);
+    const path entry = *it;
+
+    recursive_directory_iterator it2 = createDifferentInterestingIterator();
+    const recursive_directory_iterator it2_copy(it2);
+    TEST_REQUIRE(it2 != it);
+    TEST_CHECK(it2.options() != it.options());
+    TEST_CHECK(it2.depth() != it.depth());
+    TEST_CHECK(it2.recursion_pending() != it.recursion_pending());
+    TEST_CHECK(*it2 != entry);
+
+    it2 = std::move(it);
+    TEST_REQUIRE(it2 != it2_copy && it2 != endIt);
+    TEST_CHECK(it2.options() == it_copy.options());
+    TEST_CHECK(it2.depth() == it_copy.depth());
+    TEST_CHECK(it2.recursion_pending() == it_copy.recursion_pending());
+    TEST_CHECK(*it2 == entry);
+    TEST_CHECK(it == endIt || it == it2);
+}
+
+TEST_CASE(test_returns_reference_to_self)
+{
+    recursive_directory_iterator it;
+    recursive_directory_iterator it2;
+    recursive_directory_iterator& ref = (it2 = std::move(it));
+    TEST_CHECK(&ref == &it2);
+}
+
+TEST_CASE(test_self_move)
+{
+    // Create two non-equal iterators that have exactly the same state.
+    recursive_directory_iterator it = createInterestingIterator();
+    recursive_directory_iterator it2 = createInterestingIterator();
+    TEST_CHECK(it != it2);
+    TEST_CHECK(it2.options()           == it.options());
+    TEST_CHECK(it2.depth()             == it.depth());
+    TEST_CHECK(it2.recursion_pending() == it.recursion_pending());
+    TEST_CHECK(*it2 == *it);
+
+    it = std::move(it);
+    TEST_CHECK(it2.options()           == it.options());
+    TEST_CHECK(it2.depth()             == it.depth());
+    TEST_CHECK(it2.recursion_pending() == it.recursion_pending());
+    TEST_CHECK(*it2 == *it);
+}
+
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/pop.pass.cpp b/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/pop.pass.cpp
new file mode 100644
index 000000000000..befa30484c0c
--- /dev/null
+++ b/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/pop.pass.cpp
@@ -0,0 +1,93 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class recursive_directory_iterator
+
+// void pop();
+// void pop(error_code& ec);
+
+#include <experimental/filesystem>
+#include <set>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+
+TEST_SUITE(recursive_directory_iterator_pop_tests)
+
+TEST_CASE(signature_tests)
+{
+    recursive_directory_iterator it{}; ((void)it);
+    std::error_code ec; ((void)ec);
+    ASSERT_NOT_NOEXCEPT(it.pop());
+    ASSERT_NOT_NOEXCEPT(it.pop(ec)); // may require allocation or other things
+}
+
+// NOTE: Since the order of iteration is unspecified we use a list of
+// seen files at each depth to determine the new depth after a 'pop()' operation.
+TEST_CASE(test_depth)
+{
+    const recursive_directory_iterator endIt{};
+
+    auto& DE0 = StaticEnv::DirIterationList;
+    std::set<path> notSeenDepth0(std::begin(DE0), std::end(DE0));
+
+    auto& DE1 = StaticEnv::DirIterationListDepth1;
+    std::set<path> notSeenDepth1(std::begin(DE1), std::end(DE1));
+
+    std::error_code ec;
+    recursive_directory_iterator it(StaticEnv::Dir, ec);
+    TEST_REQUIRE(it != endIt);
+    TEST_CHECK(it.depth() == 0);
+
+    while (it.depth() != 2) {
+        if (it.depth() == 0)
+            notSeenDepth0.erase(it->path());
+        else
+            notSeenDepth1.erase(it->path());
+        ++it;
+        TEST_REQUIRE(it != endIt);
+    }
+
+    while (true) {
+        auto set_ec = std::make_error_code(std::errc::address_in_use);
+        it.pop(set_ec);
+        TEST_REQUIRE(!set_ec);
+
+        if (it == endIt) {
+            // We must have seen every entry at depth 0 and 1.
+            TEST_REQUIRE(notSeenDepth0.empty() && notSeenDepth1.empty());
+            break;
+        }
+        else if (it.depth() == 1) {
+            // If we popped to depth 1 then there must be unseen entries
+            // at this level.
+            TEST_REQUIRE(!notSeenDepth1.empty());
+            TEST_CHECK(notSeenDepth1.count(it->path()));
+            notSeenDepth1.clear();
+        }
+        else if (it.depth() == 0) {
+            // If we popped to depth 0 there must be unseen entries at this
+            // level. There should also be no unseen entries at depth 1.
+            TEST_REQUIRE(!notSeenDepth0.empty());
+            TEST_REQUIRE(notSeenDepth1.empty());
+            TEST_CHECK(notSeenDepth0.count(it->path()));
+            notSeenDepth0.clear();
+        }
+    }
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/recursion_pending.pass.cpp b/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/recursion_pending.pass.cpp
new file mode 100644
index 000000000000..5a3bdd9d482b
--- /dev/null
+++ b/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/recursion_pending.pass.cpp
@@ -0,0 +1,162 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// class recursive_directory_iterator
+
+// bool recursion_pending() const;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <set>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+
+TEST_SUITE(recursive_directory_iterator_recursion_pending_tests)
+
+TEST_CASE(initial_value_test)
+{
+    recursive_directory_iterator it(StaticEnv::Dir);
+    TEST_REQUIRE(it.recursion_pending() == true);
+}
+
+TEST_CASE(value_after_copy_construction_and_assignment_test)
+{
+    recursive_directory_iterator rec_pending_it(StaticEnv::Dir);
+    recursive_directory_iterator no_rec_pending_it(StaticEnv::Dir);
+    no_rec_pending_it.disable_recursion_pending();
+
+    { // copy construction
+        recursive_directory_iterator it(rec_pending_it);
+        TEST_CHECK(it.recursion_pending() == true);
+        it.disable_recursion_pending();
+        TEST_REQUIRE(rec_pending_it.recursion_pending() == true);
+
+        recursive_directory_iterator it2(no_rec_pending_it);
+        TEST_CHECK(it2.recursion_pending() == false);
+    }
+    { // copy assignment
+        recursive_directory_iterator it(StaticEnv::Dir);
+        it.disable_recursion_pending();
+        it = rec_pending_it;
+        TEST_CHECK(it.recursion_pending() == true);
+        it.disable_recursion_pending();
+        TEST_REQUIRE(rec_pending_it.recursion_pending() == true);
+
+        recursive_directory_iterator it2(StaticEnv::Dir);
+        it2 = no_rec_pending_it;
+        TEST_CHECK(it2.recursion_pending() == false);
+    }
+    TEST_CHECK(rec_pending_it.recursion_pending() == true);
+    TEST_CHECK(no_rec_pending_it.recursion_pending() == false);
+}
+
+
+TEST_CASE(value_after_move_construction_and_assignment_test)
+{
+    recursive_directory_iterator rec_pending_it(StaticEnv::Dir);
+    recursive_directory_iterator no_rec_pending_it(StaticEnv::Dir);
+    no_rec_pending_it.disable_recursion_pending();
+
+    { // move construction
+        recursive_directory_iterator it_cp(rec_pending_it);
+        recursive_directory_iterator it(std::move(it_cp));
+        TEST_CHECK(it.recursion_pending() == true);
+
+        recursive_directory_iterator it_cp2(no_rec_pending_it);
+        recursive_directory_iterator it2(std::move(it_cp2));
+        TEST_CHECK(it2.recursion_pending() == false);
+    }
+    { // copy assignment
+        recursive_directory_iterator it(StaticEnv::Dir);
+        it.disable_recursion_pending();
+        recursive_directory_iterator it_cp(rec_pending_it);
+        it = std::move(it_cp);
+        TEST_CHECK(it.recursion_pending() == true);
+
+        recursive_directory_iterator it2(StaticEnv::Dir);
+        recursive_directory_iterator it_cp2(no_rec_pending_it);
+        it2 = std::move(it_cp2);
+        TEST_CHECK(it2.recursion_pending() == false);
+    }
+    TEST_CHECK(rec_pending_it.recursion_pending() == true);
+    TEST_CHECK(no_rec_pending_it.recursion_pending() == false);
+}
+
+TEST_CASE(increment_resets_value)
+{
+    const recursive_directory_iterator endIt;
+    {
+        recursive_directory_iterator it(StaticEnv::Dir);
+        it.disable_recursion_pending();
+        TEST_CHECK(it.recursion_pending() == false);
+        ++it;
+        TEST_CHECK(it.recursion_pending() == true);
+        TEST_CHECK(it.depth() == 0);
+    }
+    {
+        recursive_directory_iterator it(StaticEnv::Dir);
+        it.disable_recursion_pending();
+        TEST_CHECK(it.recursion_pending() == false);
+        it++;
+        TEST_CHECK(it.recursion_pending() == true);
+        TEST_CHECK(it.depth() == 0);
+    }
+    {
+        recursive_directory_iterator it(StaticEnv::Dir);
+        it.disable_recursion_pending();
+        TEST_CHECK(it.recursion_pending() == false);
+        std::error_code ec;
+        it.increment(ec);
+        TEST_CHECK(it.recursion_pending() == true);
+        TEST_CHECK(it.depth() == 0);
+    }
+}
+
+TEST_CASE(pop_does_not_reset_value)
+{
+    const recursive_directory_iterator endIt;
+
+    auto& DE0 = StaticEnv::DirIterationList;
+    std::set<path> notSeenDepth0(std::begin(DE0), std::end(DE0));
+
+    recursive_directory_iterator it(StaticEnv::Dir);
+    TEST_REQUIRE(it != endIt);
+
+    while (it.depth() == 0) {
+        notSeenDepth0.erase(it->path());
+        ++it;
+        TEST_REQUIRE(it != endIt);
+    }
+    TEST_REQUIRE(it.depth() == 1);
+    it.disable_recursion_pending();
+    it.pop();
+    // Since the order of iteration is unspecified the pop() could result
+    // in the end iterator. When this is the case it is undefined behavior
+    // to call recursion_pending().
+    if (it == endIt) {
+        TEST_CHECK(notSeenDepth0.empty());
+#if defined(_LIBCPP_VERSION)
+        TEST_CHECK(it.recursion_pending() == false);
+#endif
+    } else {
+        TEST_CHECK(! notSeenDepth0.empty());
+        TEST_CHECK(it.recursion_pending() == false);
+    }
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.nonmembers/begin_end.pass.cpp b/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.nonmembers/begin_end.pass.cpp
new file mode 100644
index 000000000000..ca5117f0e32f
--- /dev/null
+++ b/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.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
+
+// <experimental/filesystem>
+
+// class recursive_directory_iterator
+
+// recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept;
+// recursive_directory_iterator end(recursive_directory_iterator iter) noexcept;
+
+#include <experimental/filesystem>
+#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 std::experimental::filesystem;
+
+TEST_SUITE(recursive_directory_iterator_begin_end_tests)
+
+TEST_CASE(test_function_signatures)
+{
+    using D = recursive_directory_iterator;
+    recursive_directory_iterator d; ((void)d);
+
+    ASSERT_SAME_TYPE(decltype(begin(d)), recursive_directory_iterator);
+    ASSERT_NOEXCEPT(begin(std::move(d)));
+
+    ASSERT_SAME_TYPE(decltype(end(d)), recursive_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::RecDirIterationList),
+                                std::end(  StaticEnv::RecDirIterationList));
+
+    std::error_code ec;
+    recursive_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/test/std/experimental/filesystem/fs.enum/check_bitmask_types.hpp b/test/std/experimental/filesystem/fs.enum/check_bitmask_types.hpp
new file mode 100644
index 000000000000..77b136f3fcad
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.enum/check_bitmask_types.hpp
@@ -0,0 +1,75 @@
+#ifndef TEST_BITMASK_TYPE_HPP
+#define TEST_BITMASK_TYPE_HPP
+
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+
+template <class EnumType, EnumType Val1, EnumType Val2,
+          class UT = typename std::underlying_type<EnumType>::type,
+          UT UVal1 = static_cast<UT>(Val1),
+          UT UVal2 = static_cast<UT>(Val2),
+          UT UZero = static_cast<UT>(0),
+          EnumType Zero = static_cast<EnumType>(0)
+        >
+struct check_bitmask_type {
+
+  static constexpr UT dcast(EnumType e) { return static_cast<UT>(e); }
+  static constexpr UT unpromote(decltype((~UZero)) promoted) { return static_cast<UT>(promoted); }
+  // We need two values that are non-zero and share at least one bit.
+  static_assert(Val1 != Zero && Val2 != Zero, "");
+  static_assert(Val1 != Val2, "");
+  static_assert((UVal1 & UVal2) == 0, "");
+
+
+  static bool check()
+  {
+    {
+      EnumType ValRef = Val1;
+      ASSERT_SAME_TYPE(EnumType, decltype(Val1 & Val2));
+      ASSERT_SAME_TYPE(EnumType, decltype(Val1 | Val2));
+      ASSERT_SAME_TYPE(EnumType, decltype(Val1 ^ Val2));
+      ASSERT_SAME_TYPE(EnumType, decltype((~Val1)));
+      ASSERT_SAME_TYPE(EnumType&, decltype(ValRef &= Val2));
+      ASSERT_SAME_TYPE(EnumType&, decltype(ValRef |= Val2));
+      ASSERT_SAME_TYPE(EnumType&, decltype(ValRef ^= Val2));
+    }
+
+    static_assert((Val1 & Zero) == Zero, "");
+    static_assert((Val1 & Val1) == Val1, "");
+    static_assert(dcast(Val1 & Val2) == (UVal1 & UVal2), "");
+
+    static_assert((Val1 | Zero) == Val1, "");
+    static_assert(dcast(Val1 | Val2) == (UVal1 | UVal2), "");
+
+    static_assert((Val1 ^ Zero) == Val1, "");
+    static_assert(dcast(Val1 ^ Val2) == (UVal1 ^ UVal2), "");
+
+    static_assert(dcast(~Zero) == unpromote(~UZero), "");
+    static_assert(dcast(~Val1) == unpromote(~UVal1), "");
+
+    {
+      EnumType e = Val1;
+      EnumType& eref = (e &= Val2);
+      assert(&eref == &e);
+      assert(dcast(eref) == (UVal1 & UVal2));
+    }
+    {
+      EnumType e = Val1;
+      EnumType& eref = (e |= Val2);
+      assert(&eref == &e);
+      assert(dcast(eref) == (UVal1 | UVal2));
+    }
+    {
+      EnumType e = Val1;
+      EnumType& eref = (e ^= Val2);
+      assert(&eref == &e);
+      assert(dcast(eref) == (UVal1 ^ UVal2));
+    }
+    return true;
+  }
+};
+
+#endif // TEST_BITMASK_TYPE
diff --git a/test/std/experimental/filesystem/fs.enum/enum.copy_options.pass.cpp b/test/std/experimental/filesystem/fs.enum/enum.copy_options.pass.cpp
new file mode 100644
index 000000000000..22f0cb845a72
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.enum/enum.copy_options.pass.cpp
@@ -0,0 +1,64 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// enum class copy_options;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "check_bitmask_types.hpp"
+#include "test_macros.h"
+
+namespace fs = std::experimental::filesystem;
+
+constexpr fs::copy_options ME(int val) { return static_cast<fs::copy_options>(val); }
+
+int main() {
+  typedef fs::copy_options E;
+  static_assert(std::is_enum<E>::value, "");
+
+  // Check that E is a scoped enum by checking for conversions.
+  typedef std::underlying_type<E>::type UT;
+  static_assert(!std::is_convertible<E, UT>::value, "");
+
+  static_assert(std::is_same<UT, unsigned short>::value, ""); // Implementation detail
+
+  typedef check_bitmask_type<E, E::skip_existing, E::update_existing> BitmaskTester;
+  assert(BitmaskTester::check());
+
+  static_assert(
+          E::none == ME(0),
+        "Expected enumeration values do not match");
+  // Option group for copy_file
+  static_assert(
+          E::skip_existing      == ME(1) &&
+          E::overwrite_existing == ME(2) &&
+          E::update_existing    == ME(4),
+        "Expected enumeration values do not match");
+  // Option group for copy on directories
+  static_assert(
+          E::recursive == ME(8),
+        "Expected enumeration values do not match");
+  // Option group for copy on symlinks
+  static_assert(
+          E::copy_symlinks == ME(16) &&
+          E::skip_symlinks == ME(32),
+        "Expected enumeration values do not match");
+  // Option group for changing form of copy
+  static_assert(
+          E::directories_only    == ME(64) &&
+          E::create_symlinks     == ME(128) &&
+          E::create_hard_links   == ME(256),
+        "Expected enumeration values do not match");
+}
diff --git a/test/std/experimental/filesystem/fs.enum/enum.directory_options.pass.cpp b/test/std/experimental/filesystem/fs.enum/enum.directory_options.pass.cpp
new file mode 100644
index 000000000000..7dbf7b2887e8
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.enum/enum.directory_options.pass.cpp
@@ -0,0 +1,46 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// enum class directory_options;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+#include <sys/stat.h>
+
+#include "test_macros.h"
+#include "check_bitmask_types.hpp"
+
+namespace fs = std::experimental::filesystem;
+
+constexpr fs::directory_options ME(int val) { return static_cast<fs::directory_options>(val); }
+
+int main() {
+  typedef fs::directory_options E;
+  static_assert(std::is_enum<E>::value, "");
+
+  // Check that E is a scoped enum by checking for conversions.
+  typedef std::underlying_type<E>::type UT;
+  static_assert(!std::is_convertible<E, UT>::value, "");
+  static_assert(std::is_same<UT, unsigned char>::value, "");
+
+  typedef check_bitmask_type<E, E::follow_directory_symlink, E::skip_permission_denied> BitmaskTester;
+  assert(BitmaskTester::check());
+
+  static_assert(
+        E::none                     == ME(0) &&
+        E::follow_directory_symlink == ME(1) &&
+        E::skip_permission_denied   == ME(2),
+        "Expected enumeration values do not match");
+
+}
diff --git a/test/std/experimental/filesystem/fs.enum/enum.file_type.pass.cpp b/test/std/experimental/filesystem/fs.enum/enum.file_type.pass.cpp
new file mode 100644
index 000000000000..ab94ad2877aa
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.enum/enum.file_type.pass.cpp
@@ -0,0 +1,48 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// enum class file_type;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+namespace fs = std::experimental::filesystem;
+
+constexpr fs::file_type ME(int val) { return static_cast<fs::file_type>(val); }
+
+int main() {
+  typedef fs::file_type E;
+  static_assert(std::is_enum<E>::value, "");
+
+  // Check that E is a scoped enum by checking for conversions.
+  typedef std::underlying_type<E>::type UT;
+  static_assert(!std::is_convertible<E, UT>::value, "");
+
+  static_assert(std::is_same<UT, signed char>::value, ""); // Implementation detail
+
+  static_assert(
+          E::none == ME(0) &&
+          E::not_found == ME(-1) &&
+          E::regular == ME(1) &&
+          E::directory == ME(2) &&
+          E::symlink == ME(3) &&
+          E::block == ME(4) &&
+          E::character == ME(5) &&
+          E::fifo == ME(6) &&
+          E::socket == ME(7) &&
+          E::unknown == ME(8),
+        "Expected enumeration values do not match");
+}
diff --git a/test/std/experimental/filesystem/fs.enum/enum.perms.pass.cpp b/test/std/experimental/filesystem/fs.enum/enum.perms.pass.cpp
new file mode 100644
index 000000000000..c0b14ba4b9b9
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.enum/enum.perms.pass.cpp
@@ -0,0 +1,68 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// enum class perms;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+#include <sys/stat.h>
+
+#include "test_macros.h"
+#include "check_bitmask_types.hpp"
+
+namespace fs = std::experimental::filesystem;
+
+constexpr fs::perms ME(int val) { return static_cast<fs::perms>(val); }
+
+int main() {
+  typedef fs::perms E;
+  static_assert(std::is_enum<E>::value, "");
+
+  // Check that E is a scoped enum by checking for conversions.
+  typedef std::underlying_type<E>::type UT;
+  static_assert(!std::is_convertible<E, UT>::value, "");
+
+  static_assert(std::is_same<UT, unsigned >::value, ""); // Implementation detail
+
+  typedef check_bitmask_type<E, E::group_all, E::owner_all> BitmaskTester;
+  assert(BitmaskTester::check());
+
+  static_assert(
+        E::none         == ME(0) &&
+
+        E::owner_read   == ME(0400) &&
+        E::owner_write  == ME(0200) &&
+        E::owner_exec   == ME(0100) &&
+        E::owner_all    == ME(0700) &&
+
+        E::group_read   == ME(040) &&
+        E::group_write  == ME(020) &&
+        E::group_exec   == ME(010) &&
+        E::group_all    == ME(070) &&
+
+        E::others_read  == ME(04) &&
+        E::others_write == ME(02) &&
+        E::others_exec  == ME(01) &&
+        E::others_all   == ME(07) &&
+        E::all          == ME(0777) &&
+        E::set_uid      == ME(04000) &&
+        E::set_gid      == ME(02000) &&
+        E::sticky_bit   == ME(01000) &&
+        E::mask         == ME(07777) &&
+        E::unknown      == ME(0xFFFF) &&
+        E::add_perms        == ME(0x10000) &&
+        E::remove_perms     == ME(0x20000) &&
+        E::symlink_nofollow == ME(0x40000),
+        "Expected enumeration values do not match");
+}
diff --git a/test/std/experimental/filesystem/fs.error.report/tested_elsewhere.pass.cpp b/test/std/experimental/filesystem/fs.error.report/tested_elsewhere.pass.cpp
new file mode 100644
index 000000000000..b58f5c55b643
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.error.report/tested_elsewhere.pass.cpp
@@ -0,0 +1,12 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+int main()
+{
+}
diff --git a/test/std/experimental/filesystem/fs.filesystem.synopsis/file_time_type.pass.cpp b/test/std/experimental/filesystem/fs.filesystem.synopsis/file_time_type.pass.cpp
new file mode 100644
index 000000000000..d8d92c5888ac
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.filesystem.synopsis/file_time_type.pass.cpp
@@ -0,0 +1,31 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// typedef TrivialClock file_time_type;
+
+#include <experimental/filesystem>
+#include <chrono>
+#include <type_traits>
+
+// system_clock is used because it meets the requirements of TrivialClock,
+// and it's resolution and range of system_clock should match the operating
+// systems file time type.
+typedef std::chrono::system_clock              ExpectedClock;
+typedef std::chrono::time_point<ExpectedClock> ExpectedTimePoint;
+
+int main() {
+  static_assert(std::is_same<
+          std::experimental::filesystem::file_time_type,
+          ExpectedTimePoint
+      >::value, "");
+}
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.absolute/absolute.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.absolute/absolute.pass.cpp
new file mode 100644
index 000000000000..4d59235c722b
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.absolute/absolute.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
+
+// <experimental/filesystem>
+
+// path absolute(const path& p, const path& base=current_path());
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+
+TEST_SUITE(filesystem_absolute_path_test_suite)
+
+TEST_CASE(absolute_signature_test)
+{
+    const path p; ((void)p);
+    ASSERT_NOT_NOEXCEPT(absolute(p));
+    ASSERT_NOT_NOEXCEPT(absolute(p, p));
+}
+
+// There are 4 cases is the proposal for absolute path.
+// Each scope tests one of the cases.
+TEST_CASE(absolute_path_test)
+{
+    // has_root_name() && has_root_directory()
+    {
+        const path p("//net/foo");
+        const path base("//net/bar/baz");
+        TEST_REQUIRE(p.has_root_name());
+        TEST_REQUIRE(p.has_root_directory());
+        TEST_CHECK(p.is_absolute());
+        path ret = absolute(p, base);
+        TEST_CHECK(ret.is_absolute());
+        TEST_CHECK(ret == p);
+    }
+    // !has_root_name() && has_root_directory()
+    {
+        const path p("/foo");
+        const path base("//net/bar");
+        TEST_REQUIRE(not p.has_root_name());
+        TEST_REQUIRE(p.has_root_directory());
+        TEST_CHECK(p.is_absolute());
+        // ensure absolute(base) is not recursivly called
+        TEST_REQUIRE(base.has_root_name());
+        TEST_REQUIRE(base.has_root_directory());
+
+        path ret = absolute(p, base);
+        TEST_CHECK(ret.is_absolute());
+        TEST_CHECK(ret.has_root_name());
+        TEST_CHECK(ret.root_name() == path("//net"));
+        TEST_CHECK(ret.has_root_directory());
+        TEST_CHECK(ret.root_directory() == path("/"));
+        TEST_CHECK(ret == path("//net/foo"));
+    }
+    // has_root_name() && !has_root_directory()
+    {
+        const path p("//net");
+        const path base("//net/foo/bar");
+        TEST_REQUIRE(p.has_root_name());
+        TEST_REQUIRE(not p.has_root_directory());
+        TEST_CHECK(not p.is_absolute());
+        // absolute is called recursivly on base. The following conditions
+        // must be true for it to return base unmodified
+        TEST_REQUIRE(base.has_root_name());
+        TEST_REQUIRE(base.has_root_directory());
+        path ret = absolute(p, base);
+        const path expect("//net/foo/bar");
+        TEST_CHECK(ret.is_absolute());
+        TEST_CHECK(ret == path("//net/foo/bar"));
+    }
+    // !has_root_name() && !has_root_directory()
+    {
+        const path p("bar/baz");
+        const path base("//net/foo");
+        TEST_REQUIRE(not p.has_root_name());
+        TEST_REQUIRE(not p.has_root_directory());
+        TEST_REQUIRE(base.has_root_name());
+        TEST_REQUIRE(base.has_root_directory());
+
+        path ret = absolute(p, base);
+        TEST_CHECK(ret.is_absolute());
+        TEST_CHECK(ret == path("//net/foo/bar/baz"));
+    }
+}
+
+TEST_CASE(absolute_path_with_default_base)
+{
+    const path testCases[] = {
+        "//net/foo", //  has_root_name() &&  has_root_directory()
+        "/foo",      // !has_root_name() &&  has_root_directory()
+        "//net",     //  has_root_name() && !has_root_directory()
+        "bar/baz"    // !has_root_name() && !has_root_directory()
+    };
+    const path base = current_path();
+    for (auto& p : testCases) {
+        const path ret = absolute(p);
+        const path expect = absolute(p, base);
+        TEST_CHECK(ret.is_absolute());
+        TEST_CHECK(ret == expect);
+    }
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.canonical/canonical.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.canonical/canonical.pass.cpp
new file mode 100644
index 000000000000..407f5b111a83
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.canonical/canonical.pass.cpp
@@ -0,0 +1,120 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// path canonical(const path& p, const path& base = current_path());
+// path canonical(const path& p, error_code& ec);
+// path canonical(const path& p, const path& base, error_code& ec);
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+
+TEST_SUITE(filesystem_canonical_path_test_suite)
+
+TEST_CASE(signature_test)
+{
+    const path p; ((void)p);
+    std::error_code ec; ((void)ec);
+    ASSERT_NOT_NOEXCEPT(canonical(p));
+    ASSERT_NOT_NOEXCEPT(canonical(p, p));
+    ASSERT_NOT_NOEXCEPT(canonical(p, ec));
+    ASSERT_NOT_NOEXCEPT(canonical(p, p, ec));
+}
+
+// There are 4 cases is the proposal for absolute path.
+// Each scope tests one of the cases.
+TEST_CASE(test_canonical)
+{
+    // has_root_name() && has_root_directory()
+    const path Root = StaticEnv::Root;
+    const path RootName = Root.filename();
+    const path DirName = StaticEnv::Dir.filename();
+    const path SymlinkName = StaticEnv::SymlinkToFile.filename();
+    struct TestCase {
+        path p;
+        path expect;
+        path base;
+        TestCase(path p1, path e, path b = StaticEnv::Root)
+            : p(p1), expect(e), base(b) {}
+    };
+    const TestCase testCases[] = {
+        { ".", Root, Root},
+        { DirName / ".." / "." / DirName, StaticEnv::Dir, Root},
+        { StaticEnv::Dir2 / "..",    StaticEnv::Dir },
+        { StaticEnv::Dir3 / "../..", StaticEnv::Dir },
+        { StaticEnv::Dir / ".",      StaticEnv::Dir },
+        { Root / "." / DirName / ".." / DirName, StaticEnv::Dir},
+        { path("..") / "." / RootName / DirName / ".." / DirName, StaticEnv::Dir, Root},
+        { StaticEnv::SymlinkToFile,  StaticEnv::File },
+        { SymlinkName, StaticEnv::File, StaticEnv::Root}
+    };
+    for (auto& TC : testCases) {
+        std::error_code ec;
+        const path ret = canonical(TC.p, TC.base, ec);
+        TEST_REQUIRE(!ec);
+        const path ret2 = canonical(TC.p, TC.base);
+        TEST_CHECK(ret == TC.expect);
+        TEST_CHECK(ret == ret2);
+        TEST_CHECK(ret.is_absolute());
+    }
+}
+
+TEST_CASE(test_dne_path)
+{
+    std::error_code ec;
+    {
+        const path ret = canonical(StaticEnv::DNE, ec);
+        TEST_REQUIRE(ec);
+        TEST_CHECK(ret == path{});
+    }
+    ec.clear();
+    {
+        const path ret = canonical(StaticEnv::DNE, StaticEnv::Root, ec);
+        TEST_REQUIRE(ec);
+        TEST_CHECK(ret == path{});
+    }
+    {
+        TEST_CHECK_THROW(filesystem_error, canonical(StaticEnv::DNE));
+        TEST_CHECK_THROW(filesystem_error, canonical(StaticEnv::DNE, StaticEnv::Root));
+    }
+}
+
+TEST_CASE(test_exception_contains_paths)
+{
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    const path p = "blabla/dne";
+    const path base = StaticEnv::Root;
+    try {
+        canonical(p, base);
+        TEST_REQUIRE(false);
+    } catch (filesystem_error const& err) {
+        TEST_CHECK(err.path1() == p);
+        TEST_CHECK(err.path2() == base);
+    }
+    try {
+        canonical(p);
+        TEST_REQUIRE(false);
+    } catch (filesystem_error const& err) {
+        TEST_CHECK(err.path1() == p);
+        TEST_CHECK(err.path2() == current_path());
+    }
+#endif
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.copy/copy.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.copy/copy.pass.cpp
new file mode 100644
index 000000000000..7d318719f740
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.copy/copy.pass.cpp
@@ -0,0 +1,251 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// void copy(const path& from, const path& to);
+// void copy(const path& from, const path& to, error_code& ec) noexcept;
+// void copy(const path& from, const path& to, copy_options options);
+// void copy(const path& from, const path& to, copy_options options,
+//           error_code& ec) noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+namespace fs = std::experimental::filesystem;
+
+using CO = fs::copy_options;
+
+TEST_SUITE(filesystem_copy_test_suite)
+
+TEST_CASE(signature_test)
+{
+    const path p; ((void)p);
+    std::error_code ec; ((void)ec);
+    const copy_options opts{}; ((void)opts);
+    ASSERT_NOT_NOEXCEPT(fs::copy(p, p));
+    ASSERT_NOEXCEPT(fs::copy(p, p, ec));
+    ASSERT_NOT_NOEXCEPT(copy(p, p, opts));
+    ASSERT_NOEXCEPT(copy(p, p, opts, ec));
+}
+
+// There are 4 cases is the proposal for absolute path.
+// Each scope tests one of the cases.
+TEST_CASE(test_error_reporting)
+{
+    auto checkThrow = [](path const& f, path const& t, const std::error_code& ec)
+    {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+        try {
+            fs::copy(f, t);
+            return false;
+        } catch (filesystem_error const& err) {
+            return err.path1() == f
+                && err.path2() == t
+                && err.code() == ec;
+        }
+#else
+        return true;
+#endif
+    };
+
+    scoped_test_env env;
+    const path file = env.create_file("file1", 42);
+    const path dir = env.create_dir("dir");
+    const path fifo = env.create_fifo("fifo");
+    TEST_REQUIRE(is_other(fifo));
+
+    // !exists(f)
+    {
+        std::error_code ec;
+        const path f = StaticEnv::DNE;
+        const path t = env.test_root;
+        fs::copy(f, t, ec);
+        TEST_REQUIRE(ec);
+        TEST_CHECK(checkThrow(f, t, ec));
+    }
+    { // equivalent(f, t) == true
+        std::error_code ec;
+        fs::copy(file, file, ec);
+        TEST_REQUIRE(ec);
+        TEST_CHECK(checkThrow(file, file, ec));
+    }
+    { // is_directory(from) && is_file(to)
+        std::error_code ec;
+        fs::copy(dir, file, ec);
+        TEST_REQUIRE(ec);
+        TEST_CHECK(checkThrow(dir, file, ec));
+    }
+    { // is_other(from)
+        std::error_code ec;
+        fs::copy(fifo, dir, ec);
+        TEST_REQUIRE(ec);
+        TEST_CHECK(checkThrow(fifo, dir, ec));
+    }
+    { // is_other(to)
+        std::error_code ec;
+        fs::copy(file, fifo, ec);
+        TEST_REQUIRE(ec);
+        TEST_CHECK(checkThrow(file, fifo, ec));
+    }
+}
+
+TEST_CASE(from_is_symlink)
+{
+    scoped_test_env env;
+    const path file = env.create_file("file", 42);
+    const path symlink = env.create_symlink(file, "sym");
+    const path dne = env.make_env_path("dne");
+
+    { // skip symlinks
+        std::error_code ec = GetTestEC();
+        fs::copy(symlink, dne, copy_options::skip_symlinks, ec);
+        TEST_CHECK(!ec);
+        TEST_CHECK(!exists(dne));
+    }
+    {
+        const path dest = env.make_env_path("dest");
+        std::error_code ec = GetTestEC();
+        fs::copy(symlink, dest, copy_options::copy_symlinks, ec);
+        TEST_CHECK(!ec);
+        TEST_CHECK(exists(dest));
+        TEST_CHECK(is_symlink(dest));
+    }
+    { // copy symlink but target exists
+        std::error_code ec = GetTestEC();
+        fs::copy(symlink, file, copy_options::copy_symlinks, ec);
+        TEST_CHECK(ec);
+    }
+    { // create symlinks but target exists
+        std::error_code ec = GetTestEC();
+        fs::copy(symlink, file, copy_options::create_symlinks, ec);
+        TEST_CHECK(ec);
+    }
+}
+
+TEST_CASE(from_is_regular_file)
+{
+    scoped_test_env env;
+    const path file = env.create_file("file", 42);
+    const path dir = env.create_dir("dir");
+    { // skip copy because of directory
+        const path dest = env.make_env_path("dest1");
+        std::error_code ec = GetTestEC();
+        fs::copy(file, dest, CO::directories_only, ec);
+        TEST_CHECK(!ec);
+        TEST_CHECK(!exists(dest));
+    }
+    { // create symlink to file
+        const path dest = env.make_env_path("sym");
+        std::error_code ec = GetTestEC();
+        fs::copy(file, dest, CO::create_symlinks, ec);
+        TEST_CHECK(!ec);
+        TEST_CHECK(is_symlink(dest));
+        TEST_CHECK(equivalent(file, canonical(dest)));
+    }
+    { // create hard link to file
+        const path dest = env.make_env_path("hardlink");
+        TEST_CHECK(hard_link_count(file) == 1);
+        std::error_code ec = GetTestEC();
+        fs::copy(file, dest, CO::create_hard_links, ec);
+        TEST_CHECK(!ec);
+        TEST_CHECK(exists(dest));
+        TEST_CHECK(hard_link_count(file) == 2);
+    }
+    { // is_directory(t)
+        const path dest_dir = env.create_dir("dest_dir");
+        const path expect_dest = dest_dir / file.filename();
+        std::error_code ec = GetTestEC();
+        fs::copy(file, dest_dir, ec);
+        TEST_CHECK(!ec);
+        TEST_CHECK(is_regular_file(expect_dest));
+    }
+    { // otherwise copy_file(from, to, ...)
+        const path dest = env.make_env_path("file_copy");
+        std::error_code ec = GetTestEC();
+        fs::copy(file, dest, ec);
+        TEST_CHECK(!ec);
+        TEST_CHECK(is_regular_file(dest));
+    }
+}
+
+TEST_CASE(from_is_directory)
+{
+    struct FileInfo {
+        path filename;
+        int size;
+    };
+    const FileInfo files[] = {
+        {"file1", 0},
+        {"file2", 42},
+        {"file3", 300}
+    };
+    scoped_test_env env;
+    const path dir = env.create_dir("dir");
+    const path nested_dir_name = "dir2";
+    const path nested_dir = env.create_dir("dir/dir2");
+
+    for (auto& FI : files) {
+        env.create_file(dir / FI.filename, FI.size);
+        env.create_file(nested_dir / FI.filename, FI.size);
+    }
+    { // test for non-existent directory
+        const path dest = env.make_env_path("dest_dir1");
+        std::error_code ec = GetTestEC();
+        fs::copy(dir, dest, ec);
+        TEST_REQUIRE(!ec);
+        TEST_CHECK(is_directory(dest));
+        for (auto& FI : files) {
+            path created = dest / FI.filename;
+            TEST_CHECK(is_regular_file(created));
+            TEST_CHECK(file_size(created) == FI.size);
+        }
+        TEST_CHECK(!is_directory(dest / nested_dir_name));
+    }
+    { // test for existing directory
+        const path dest = env.create_dir("dest_dir2");
+        std::error_code ec = GetTestEC();
+        fs::copy(dir, dest, ec);
+        TEST_REQUIRE(!ec);
+        TEST_CHECK(is_directory(dest));
+        for (auto& FI : files) {
+            path created = dest / FI.filename;
+            TEST_CHECK(is_regular_file(created));
+            TEST_CHECK(file_size(created) == FI.size);
+        }
+        TEST_CHECK(!is_directory(dest / nested_dir_name));
+    }
+    { // test recursive copy
+        const path dest = env.make_env_path("dest_dir3");
+        std::error_code ec = GetTestEC();
+        fs::copy(dir, dest, CO::recursive, ec);
+        TEST_REQUIRE(!ec);
+        TEST_CHECK(is_directory(dest));
+        const path nested_dest = dest / nested_dir_name;
+        TEST_REQUIRE(is_directory(nested_dest));
+        for (auto& FI : files) {
+            path created = dest / FI.filename;
+            path nested_created = nested_dest / FI.filename;
+            TEST_CHECK(is_regular_file(created));
+            TEST_CHECK(file_size(created) == FI.size);
+            TEST_CHECK(is_regular_file(nested_created));
+            TEST_CHECK(file_size(nested_created) == FI.size);
+        }
+    }
+
+}
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.copy_file/copy_file.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.copy_file/copy_file.pass.cpp
new file mode 100644
index 000000000000..ac9877bbd9ce
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.copy_file/copy_file.pass.cpp
@@ -0,0 +1,164 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// bool copy_file(const path& from, const path& to);
+// bool copy_file(const path& from, const path& to, error_code& ec) noexcept;
+// bool copy_file(const path& from, const path& to, copy_options options);
+// bool copy_file(const path& from, const path& to, copy_options options,
+//           error_code& ec) noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <chrono>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+namespace fs = std::experimental::filesystem;
+
+using CO = fs::copy_options;
+
+TEST_SUITE(filesystem_copy_file_test_suite)
+
+TEST_CASE(test_signatures)
+{
+    const path p; ((void)p);
+    const copy_options opts{}; ((void)opts);
+    std::error_code ec; ((void)ec);
+    ASSERT_SAME_TYPE(decltype(fs::copy_file(p, p)), bool);
+    ASSERT_SAME_TYPE(decltype(fs::copy_file(p, p, opts)), bool);
+    ASSERT_SAME_TYPE(decltype(fs::copy_file(p, p, ec)), bool);
+    ASSERT_SAME_TYPE(decltype(fs::copy_file(p, p, opts, ec)), bool);
+    ASSERT_NOT_NOEXCEPT(fs::copy_file(p, p));
+    ASSERT_NOT_NOEXCEPT(fs::copy_file(p, p, opts));
+    ASSERT_NOEXCEPT(fs::copy_file(p, p, ec));
+    ASSERT_NOEXCEPT(fs::copy_file(p, p, opts, ec));
+}
+
+TEST_CASE(test_error_reporting)
+{
+    auto checkThrow = [](path const& f, path const& t, const std::error_code& ec)
+    {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+        try {
+            fs::copy_file(f, t);
+            return false;
+        } catch (filesystem_error const& err) {
+            return err.path1() == f
+                && err.path2() == t
+                && err.code() == ec;
+        }
+#else
+        return true;
+#endif
+    };
+
+    scoped_test_env env;
+    const path file = env.create_file("file1", 42);
+    const path file2 = env.create_file("file2", 55);
+    const path dne = env.make_env_path("dne");
+    { // exists(to) && equivalent(to, from)
+        std::error_code ec;
+        TEST_CHECK(fs::copy_file(file, file, ec) == false);
+        TEST_REQUIRE(ec);
+        TEST_CHECK(checkThrow(file, file, ec));
+    }
+    { // exists(to) && !(skip_existing | overwrite_existing | update_existing)
+        std::error_code ec;
+        TEST_CHECK(fs::copy_file(file, file2, ec) == false);
+        TEST_REQUIRE(ec);
+        TEST_CHECK(checkThrow(file, file2, ec));
+    }
+}
+
+TEST_CASE(copy_file)
+{
+    scoped_test_env env;
+    const path file = env.create_file("file1", 42);
+
+    { // !exists(to)
+        const path dest = env.make_env_path("dest1");
+        std::error_code ec;
+        TEST_REQUIRE(fs::copy_file(file, dest, ec) == true);
+        TEST_CHECK(!ec);
+        TEST_CHECK(file_size(dest) == 42);
+    }
+    { // exists(to) && overwrite_existing
+        const path dest = env.create_file("dest2", 55);
+        std::error_code ec;
+        TEST_REQUIRE(fs::copy_file(file, dest,
+                                   copy_options::overwrite_existing, ec) == true);
+        TEST_CHECK(!ec);
+        TEST_CHECK(file_size(dest) == 42);
+    }
+    { // exists(to) && update_existing
+        using Sec = std::chrono::seconds;
+        const path older = env.create_file("older_file", 1);
+
+        SleepFor(Sec(2));
+        const path from = env.create_file("update_from", 55);
+
+        SleepFor(Sec(2));
+        const path newer = env.create_file("newer_file", 2);
+
+        std::error_code ec;
+        TEST_REQUIRE(fs::copy_file(from, older, copy_options::update_existing, ec) == true);
+        TEST_CHECK(!ec);
+        TEST_CHECK(file_size(older) == 55);
+
+        TEST_REQUIRE(fs::copy_file(from, newer, copy_options::update_existing, ec) == false);
+        TEST_CHECK(!ec);
+        TEST_CHECK(file_size(newer) == 2);
+    }
+    { // skip_existing
+        const path file2 = env.create_file("file2", 55);
+        std::error_code ec;
+        TEST_REQUIRE(fs::copy_file(file, file2, copy_options::skip_existing, ec) == false);
+        TEST_CHECK(!ec);
+        TEST_CHECK(file_size(file2) == 55);
+    }
+}
+
+TEST_CASE(test_attributes_get_copied)
+{
+    scoped_test_env env;
+    const path file = env.create_file("file1", 42);
+    const path dest = env.make_env_path("file2");
+    auto st = status(file);
+    perms default_perms = st.permissions();
+    perms new_perms = perms::owner_read;
+    permissions(file, new_perms);
+    std::error_code ec;
+    TEST_REQUIRE(fs::copy_file(file, dest, ec) == true);
+    TEST_CHECK(!ec);
+    auto new_st = status(dest);
+    TEST_CHECK(new_st.permissions() == new_perms);
+}
+
+TEST_CASE(copy_dir_test)
+{
+    scoped_test_env env;
+    const path file = env.create_file("file1", 42);
+    const path dest = env.create_dir("dir1");
+    std::error_code ec;
+    TEST_CHECK(fs::copy_file(file, dest, ec) == false);
+    TEST_CHECK(ec);
+    ec.clear();
+    TEST_CHECK(fs::copy_file(dest, file, ec) == false);
+    TEST_CHECK(ec);
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.copy_symlink/copy_symlink.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.copy_symlink/copy_symlink.pass.cpp
new file mode 100644
index 000000000000..6fae11195206
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.copy_symlink/copy_symlink.pass.cpp
@@ -0,0 +1,108 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// void copy_symlink(const path& existing_symlink, const path& new_symlink);
+// void copy_symlink(const path& existing_symlink, const path& new_symlink,
+//                   error_code& ec) noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+namespace fs = std::experimental::filesystem;
+
+TEST_SUITE(filesystem_copy_symlink_test_suite)
+
+TEST_CASE(test_signatures)
+{
+    const path p; ((void)p);
+    std::error_code ec; ((void)ec);
+    ASSERT_NOT_NOEXCEPT(fs::copy_symlink(p, p));
+    ASSERT_NOEXCEPT(fs::copy_symlink(p, p, ec));
+}
+
+
+TEST_CASE(test_error_reporting)
+{
+    auto checkThrow = [](path const& f, path const& t, const std::error_code& ec)
+    {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+        try {
+            fs::copy_symlink(f, t);
+            return true;
+        } catch (filesystem_error const& err) {
+            return err.path1() == f
+                && err.code() == ec;
+        }
+#else
+        return true;
+#endif
+    };
+
+    scoped_test_env env;
+    const path file = env.create_file("file1", 42);
+    const path file2 = env.create_file("file2", 55);
+    const path sym = env.create_symlink(file, "sym");
+    const path dir = env.create_dir("dir");
+    const path dne = env.make_env_path("dne");
+    { // from is a file, not a symlink
+        std::error_code ec;
+        fs::copy_symlink(file, dne, ec);
+        TEST_REQUIRE(ec);
+        TEST_CHECK(checkThrow(file, dne, ec));
+    }
+    { // from is a file, not a symlink
+        std::error_code ec;
+        fs::copy_symlink(dir, dne, ec);
+        TEST_REQUIRE(ec);
+        TEST_CHECK(checkThrow(dir, dne, ec));
+    }
+    { // destination exists
+        std::error_code ec;
+        fs::copy_symlink(sym, file2, ec);
+        TEST_REQUIRE(ec);
+    }
+}
+
+TEST_CASE(copy_symlink_basic)
+{
+    scoped_test_env env;
+    const path dir = env.create_dir("dir");
+    const path dir_sym = env.create_symlink(dir, "dir_sym");
+    const path file = env.create_file("file", 42);
+    const path file_sym = env.create_symlink(file, "file_sym");
+    { // test for directory symlinks
+        const path dest = env.make_env_path("dest1");
+        std::error_code ec;
+        fs::copy_symlink(dir_sym, dest, ec);
+        TEST_REQUIRE(!ec);
+        TEST_CHECK(is_symlink(dest));
+        TEST_CHECK(equivalent(dest, dir));
+    }
+    { // test for file symlinks
+        const path dest = env.make_env_path("dest2");
+        std::error_code ec;
+        fs::copy_symlink(file_sym, dest, ec);
+        TEST_REQUIRE(!ec);
+        TEST_CHECK(is_symlink(dest));
+        TEST_CHECK(equivalent(dest, file));
+    }
+}
+
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.create_directories/create_directories.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.create_directories/create_directories.pass.cpp
new file mode 100644
index 000000000000..ba060254956f
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.create_directories/create_directories.pass.cpp
@@ -0,0 +1,70 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// bool create_directories(const path& p);
+// bool create_directories(const path& p, error_code& ec) noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+namespace fs = std::experimental::filesystem;
+
+TEST_SUITE(filesystem_create_directories_test_suite)
+
+TEST_CASE(test_signatures)
+{
+    const path p; ((void)p);
+    std::error_code ec; ((void)ec);
+    ASSERT_SAME_TYPE(decltype(fs::create_directories(p)), bool);
+    ASSERT_SAME_TYPE(decltype(fs::create_directories(p, ec)), bool);
+    ASSERT_NOT_NOEXCEPT(fs::create_directories(p));
+    ASSERT_NOEXCEPT(fs::create_directories(p, ec));
+}
+
+TEST_CASE(create_existing_directory)
+{
+    scoped_test_env env;
+    const path dir = env.create_dir("dir1");
+    std::error_code ec;
+    TEST_CHECK(fs::create_directories(dir, ec) == false);
+    TEST_CHECK(!ec);
+    TEST_CHECK(is_directory(dir));
+}
+
+TEST_CASE(create_directory_one_level)
+{
+    scoped_test_env env;
+    const path dir = env.make_env_path("dir1");
+    std::error_code ec;
+    TEST_CHECK(fs::create_directories(dir, ec) == true);
+    TEST_CHECK(!ec);
+    TEST_CHECK(is_directory(dir));
+}
+
+TEST_CASE(create_directories_multi_level)
+{
+    scoped_test_env env;
+    const path dir = env.make_env_path("dir1/dir2/dir3");
+    std::error_code ec;
+    TEST_CHECK(fs::create_directories(dir, ec) == true);
+    TEST_CHECK(!ec);
+    TEST_CHECK(is_directory(dir));
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.create_directory/create_directory.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.create_directory/create_directory.pass.cpp
new file mode 100644
index 000000000000..5fce217bc49e
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.create_directory/create_directory.pass.cpp
@@ -0,0 +1,104 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// bool create_directory(const path& p);
+// bool create_directory(const path& p, error_code& ec) noexcept;
+// bool create_directory(const path& p, const path& attr);
+// bool create_directory(const path& p, const path& attr, error_code& ec) noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+using namespace std::experimental::filesystem;
+namespace fs = std::experimental::filesystem;
+
+fs::perms read_umask() {
+    mode_t old_mask = umask(0);
+    umask(old_mask); // reset the mask to the old value.
+    return static_cast<fs::perms>(old_mask);
+}
+
+TEST_SUITE(filesystem_create_directory_test_suite)
+
+TEST_CASE(test_signatures)
+{
+    const path p; ((void)p);
+    std::error_code ec; ((void)ec);
+    ASSERT_SAME_TYPE(decltype(fs::create_directory(p)), bool);
+    ASSERT_SAME_TYPE(decltype(fs::create_directory(p, ec)), bool);
+    ASSERT_SAME_TYPE(decltype(fs::create_directory(p, p)), bool);
+    ASSERT_SAME_TYPE(decltype(fs::create_directory(p, p, ec)), bool);
+    ASSERT_NOT_NOEXCEPT(fs::create_directory(p));
+    ASSERT_NOEXCEPT(fs::create_directory(p, ec));
+    ASSERT_NOT_NOEXCEPT(fs::create_directory(p, p));
+    ASSERT_NOEXCEPT(fs::create_directory(p, p, ec));
+}
+
+
+TEST_CASE(create_existing_directory)
+{
+    scoped_test_env env;
+    const path dir = env.create_dir("dir1");
+    std::error_code ec;
+    TEST_CHECK(fs::create_directory(dir, ec) == false);
+    TEST_CHECK(!ec);
+    TEST_CHECK(is_directory(dir));
+    // Test throwing version
+    TEST_CHECK(fs::create_directory(dir) == false);
+}
+
+TEST_CASE(create_directory_one_level)
+{
+    scoped_test_env env;
+    const path dir = env.make_env_path("dir1");
+    std::error_code ec;
+    TEST_CHECK(fs::create_directory(dir, ec) == true);
+    TEST_CHECK(!ec);
+    TEST_CHECK(is_directory(dir));
+
+    auto st = status(dir);
+    const perms expect_perms = perms::all & ~(read_umask());
+    TEST_CHECK((st.permissions() & perms::all) == expect_perms);
+}
+
+TEST_CASE(create_directory_multi_level)
+{
+    scoped_test_env env;
+    const path dir = env.make_env_path("dir1/dir2");
+    const path dir1 = env.make_env_path("dir1");
+    std::error_code ec;
+    TEST_CHECK(fs::create_directory(dir, ec) == false);
+    TEST_CHECK(ec);
+    TEST_CHECK(!is_directory(dir));
+    TEST_CHECK(!is_directory(dir1));
+}
+
+TEST_CASE(dest_is_file)
+{
+    scoped_test_env env;
+    const path file = env.create_file("file", 42);
+    std::error_code ec;
+    TEST_CHECK(fs::create_directory(file, ec) == false);
+    TEST_CHECK(ec);
+    TEST_CHECK(is_regular_file(file));
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.create_directory/create_directory_with_attributes.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.create_directory/create_directory_with_attributes.pass.cpp
new file mode 100644
index 000000000000..c32bdd2d1928
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.create_directory/create_directory_with_attributes.pass.cpp
@@ -0,0 +1,104 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// bool create_directory(const path& p, const path& attr);
+// bool create_directory(const path& p, const path& attr, error_code& ec) noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+namespace fs = std::experimental::filesystem;
+
+TEST_SUITE(filesystem_create_directory_test_suite)
+
+TEST_CASE(test_signatures)
+{
+    const path p; ((void)p);
+    std::error_code ec; ((void)ec);
+    ASSERT_SAME_TYPE(decltype(fs::create_directory(p, p)), bool);
+    ASSERT_SAME_TYPE(decltype(fs::create_directory(p, p, ec)), bool);
+    ASSERT_NOT_NOEXCEPT(fs::create_directory(p, p));
+    ASSERT_NOEXCEPT(fs::create_directory(p, p, ec));
+}
+
+TEST_CASE(create_existing_directory)
+{
+    scoped_test_env env;
+    const path dir = env.create_dir("dir1");
+    const path dir2 = env.create_dir("dir2");
+
+    const perms orig_p = status(dir).permissions();
+    permissions(dir2, perms::none);
+
+    std::error_code ec;
+    TEST_CHECK(fs::create_directory(dir, dir2, ec) == false);
+    TEST_CHECK(!ec);
+
+    // Check that the permissions were unchanged
+    TEST_CHECK(orig_p == status(dir).permissions());
+
+    // Test throwing version
+    TEST_CHECK(fs::create_directory(dir, dir2) == false);
+}
+
+TEST_CASE(create_directory_one_level)
+{
+    scoped_test_env env;
+    // Remove setgid which mkdir would inherit
+    permissions(env.test_root, perms::remove_perms | perms::set_gid);
+
+    const path dir = env.make_env_path("dir1");
+    const path attr_dir = env.create_dir("dir2");
+    permissions(attr_dir, perms::none);
+
+    std::error_code ec;
+    TEST_CHECK(fs::create_directory(dir, attr_dir, ec) == true);
+    TEST_CHECK(!ec);
+    TEST_CHECK(is_directory(dir));
+
+    // Check that the new directory has the same permissions as attr_dir
+    auto st = status(dir);
+    TEST_CHECK(st.permissions() == perms::none);
+}
+
+TEST_CASE(create_directory_multi_level)
+{
+    scoped_test_env env;
+    const path dir = env.make_env_path("dir1/dir2");
+    const path dir1 = env.make_env_path("dir1");
+    const path attr_dir = env.create_dir("attr_dir");
+    std::error_code ec;
+    TEST_CHECK(fs::create_directory(dir, attr_dir, ec) == false);
+    TEST_CHECK(ec);
+    TEST_CHECK(!is_directory(dir));
+    TEST_CHECK(!is_directory(dir1));
+}
+
+TEST_CASE(dest_is_file)
+{
+    scoped_test_env env;
+    const path file = env.create_file("file", 42);
+    const path attr_dir = env.create_dir("attr_dir");
+    std::error_code ec;
+    TEST_CHECK(fs::create_directory(file, attr_dir, ec) == false);
+    TEST_CHECK(ec);
+    TEST_CHECK(is_regular_file(file));
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.create_directory_symlink/create_directory_symlink.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.create_directory_symlink/create_directory_symlink.pass.cpp
new file mode 100644
index 000000000000..e0473754cc88
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.create_directory_symlink/create_directory_symlink.pass.cpp
@@ -0,0 +1,81 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// void create_directory_symlink(const path& existing_symlink, const path& new_symlink);
+// void create_directory_symlink(const path& existing_symlink, const path& new_symlink,
+//                   error_code& ec) noexcept;
+
+#include <experimental/filesystem>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+namespace fs = std::experimental::filesystem;
+
+TEST_SUITE(filesystem_create_directory_symlink_test_suite)
+
+TEST_CASE(test_signatures)
+{
+    const path p; ((void)p);
+    std::error_code ec; ((void)ec);
+    ASSERT_NOT_NOEXCEPT(fs::create_directory_symlink(p, p));
+    ASSERT_NOEXCEPT(fs::create_directory_symlink(p, p, ec));
+}
+
+TEST_CASE(test_error_reporting)
+{
+    auto checkThrow = [](path const& f, path const& t, const std::error_code& ec)
+    {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+        try {
+            fs::create_directory_symlink(f, t);
+            return true;
+        } catch (filesystem_error const& err) {
+            return err.path1() == f
+                && err.code() == ec;
+        }
+#else
+        return true;
+#endif
+    };
+
+    scoped_test_env env;
+    const path file = env.create_file("file1", 42);
+    const path file2 = env.create_file("file2", 55);
+    const path sym = env.create_symlink(file, "sym");
+    { // destination exists
+        std::error_code ec;
+        fs::create_directory_symlink(sym, file2, ec);
+        TEST_REQUIRE(ec);
+    }
+}
+
+TEST_CASE(create_directory_symlink_basic)
+{
+    scoped_test_env env;
+    const path dir = env.create_dir("dir");
+    const path dir_sym = env.create_symlink(dir, "dir_sym");
+
+    const path dest = env.make_env_path("dest1");
+    std::error_code ec;
+    fs::create_directory_symlink(dir_sym, dest, ec);
+    TEST_REQUIRE(!ec);
+    TEST_CHECK(is_symlink(dest));
+    TEST_CHECK(equivalent(dest, dir));
+}
+
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.create_hard_link/create_hard_link.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.create_hard_link/create_hard_link.pass.cpp
new file mode 100644
index 000000000000..4a865fdee7e8
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.create_hard_link/create_hard_link.pass.cpp
@@ -0,0 +1,90 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// void create_hard_link(const path& existing_symlink, const path& new_symlink);
+// void create_hard_link(const path& existing_symlink, const path& new_symlink,
+//                   error_code& ec) noexcept;
+
+#include <experimental/filesystem>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+namespace fs = std::experimental::filesystem;
+
+TEST_SUITE(filesystem_create_hard_link_test_suite)
+
+TEST_CASE(test_signatures)
+{
+    const path p; ((void)p);
+    std::error_code ec; ((void)ec);
+    ASSERT_NOT_NOEXCEPT(fs::create_hard_link(p, p));
+    ASSERT_NOEXCEPT(fs::create_hard_link(p, p, ec));
+}
+
+TEST_CASE(test_error_reporting)
+{
+    auto checkThrow = [](path const& f, path const& t, const std::error_code& ec)
+    {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+        try {
+            fs::create_hard_link(f, t);
+            return true;
+        } catch (filesystem_error const& err) {
+            return err.path1() == f
+                && err.code() == ec;
+        }
+#else
+        return true;
+#endif
+    };
+
+    scoped_test_env env;
+    const path file = env.create_file("file1", 42);
+    const path file2 = env.create_file("file2", 55);
+    const path sym = env.create_symlink(file, "sym");
+    { // destination exists
+        std::error_code ec;
+        fs::create_hard_link(sym, file2, ec);
+        TEST_REQUIRE(ec);
+    }
+}
+
+TEST_CASE(create_file_hard_link)
+{
+    scoped_test_env env;
+    const path file = env.create_file("file");
+    const path dest = env.make_env_path("dest1");
+    std::error_code ec;
+    TEST_CHECK(hard_link_count(file) == 1);
+    fs::create_hard_link(file, dest, ec);
+    TEST_REQUIRE(!ec);
+    TEST_CHECK(exists(dest));
+    TEST_CHECK(equivalent(dest, file));
+    TEST_CHECK(hard_link_count(file) == 2);
+}
+
+TEST_CASE(create_directory_hard_link_fails)
+{
+    scoped_test_env env;
+    const path dir = env.create_dir("dir");
+    const path dest = env.make_env_path("dest2");
+    std::error_code ec;
+
+    fs::create_hard_link(dir, dest, ec);
+    TEST_REQUIRE(ec);
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.create_symlink/create_symlink.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.create_symlink/create_symlink.pass.cpp
new file mode 100644
index 000000000000..35ba57f3ab46
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.create_symlink/create_symlink.pass.cpp
@@ -0,0 +1,92 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// void create_symlink(const path& existing_symlink, const path& new_symlink);
+// void create_symlink(const path& existing_symlink, const path& new_symlink,
+//                   error_code& ec) noexcept;
+
+#include <experimental/filesystem>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+namespace fs = std::experimental::filesystem;
+
+TEST_SUITE(filesystem_create_symlink_test_suite)
+
+TEST_CASE(test_signatures)
+{
+    const path p; ((void)p);
+    std::error_code ec; ((void)ec);
+    ASSERT_NOT_NOEXCEPT(fs::create_symlink(p, p));
+    ASSERT_NOEXCEPT(fs::create_symlink(p, p, ec));
+}
+
+TEST_CASE(test_error_reporting)
+{
+    auto checkThrow = [](path const& f, path const& t, const std::error_code& ec)
+    {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+        try {
+            fs::create_symlink(f, t);
+            return true;
+        } catch (filesystem_error const& err) {
+            return err.path1() == f
+                && err.code() == ec;
+        }
+#else
+        return true;
+#endif
+    };
+
+    scoped_test_env env;
+    const path file = env.create_file("file1", 42);
+    const path file2 = env.create_file("file2", 55);
+    const path sym = env.create_symlink(file, "sym");
+    { // destination exists
+        std::error_code ec;
+        fs::create_symlink(sym, file2, ec);
+        TEST_REQUIRE(ec);
+    }
+}
+
+TEST_CASE(create_symlink_basic)
+{
+    scoped_test_env env;
+    const path file = env.create_file("file", 42);
+    const path file_sym = env.create_symlink(file, "file_sym");
+    const path dir = env.create_dir("dir");
+    const path dir_sym = env.create_symlink(dir, "dir_sym");
+    {
+        const path dest = env.make_env_path("dest1");
+        std::error_code ec;
+        fs::create_symlink(file_sym, dest, ec);
+        TEST_REQUIRE(!ec);
+        TEST_CHECK(is_symlink(dest));
+        TEST_CHECK(equivalent(dest, file));
+    }
+    {
+        const path dest = env.make_env_path("dest2");
+        std::error_code ec;
+        fs::create_symlink(dir_sym, dest, ec);
+        TEST_REQUIRE(!ec);
+        TEST_CHECK(is_symlink(dest));
+        TEST_CHECK(equivalent(dest, dir));
+    }
+}
+
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.current_path/current_path.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.current_path/current_path.pass.cpp
new file mode 100644
index 000000000000..9d004ab854c1
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.current_path/current_path.pass.cpp
@@ -0,0 +1,93 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// path current_path();
+// path current_path(error_code& ec);
+// void current_path(path const&);
+// void current_path(path const&, std::error_code& ec) noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+
+TEST_SUITE(filesystem_current_path_path_test_suite)
+
+TEST_CASE(current_path_signature_test)
+{
+    const path p; ((void)p);
+    std::error_code ec; ((void)ec);
+    ASSERT_NOT_NOEXCEPT(current_path());
+    ASSERT_NOT_NOEXCEPT(current_path(ec));
+    ASSERT_NOT_NOEXCEPT(current_path(p));
+    ASSERT_NOEXCEPT(current_path(p, ec));
+}
+
+TEST_CASE(current_path_test)
+{
+    std::error_code ec;
+    const path p = current_path(ec);
+    TEST_REQUIRE(!ec);
+    TEST_CHECK(p.is_absolute());
+    TEST_CHECK(is_directory(p));
+
+    const path p2 = current_path();
+    TEST_CHECK(p2 == p);
+}
+
+TEST_CASE(current_path_after_change_test)
+{
+    const path new_path = StaticEnv::Dir;
+    current_path(new_path);
+    TEST_CHECK(current_path() == new_path);
+}
+
+TEST_CASE(current_path_is_file_test)
+{
+    const path p = StaticEnv::File;
+    std::error_code ec;
+    const path old_p = current_path();
+    current_path(p, ec);
+    TEST_CHECK(ec);
+    TEST_CHECK(old_p == current_path());
+}
+
+TEST_CASE(set_to_non_absolute_path)
+{
+    const path base = StaticEnv::Dir;
+    current_path(base);
+    const path p = StaticEnv::Dir2.filename();
+    std::error_code ec;
+    current_path(p, ec);
+    TEST_CHECK(!ec);
+    const path new_cwd = current_path();
+    TEST_CHECK(new_cwd == StaticEnv::Dir2);
+    TEST_CHECK(new_cwd.is_absolute());
+}
+
+TEST_CASE(set_to_empty)
+{
+    const path p = "";
+    std::error_code ec;
+    const path old_p = current_path();
+    current_path(p, ec);
+    TEST_CHECK(ec);
+    TEST_CHECK(old_p == current_path());
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.equivalent/equivalent.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.equivalent/equivalent.pass.cpp
new file mode 100644
index 000000000000..621ff8305fc3
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.equivalent/equivalent.pass.cpp
@@ -0,0 +1,88 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// bool equivalent(path const& lhs, path const& rhs);
+// bool equivalent(path const& lhs, path const& rhs, std::error_code& ec) noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+
+TEST_SUITE(equivalent_test_suite)
+
+TEST_CASE(signature_test)
+{
+    const path p; ((void)p);
+    std::error_code ec; ((void)ec);
+    ASSERT_NOEXCEPT(equivalent(p, p, ec));
+    ASSERT_NOT_NOEXCEPT(equivalent(p, p));
+}
+
+TEST_CASE(equivalent_test)
+{
+    struct TestCase {
+        path lhs;
+        path rhs;
+        bool expect;
+    };
+    const TestCase testCases[] = {
+        {StaticEnv::Dir, StaticEnv::Dir, true},
+        {StaticEnv::File, StaticEnv::Dir, false},
+        {StaticEnv::Dir, StaticEnv::SymlinkToDir, true},
+        {StaticEnv::Dir, StaticEnv::SymlinkToFile, false},
+        {StaticEnv::File, StaticEnv::File, true},
+        {StaticEnv::File, StaticEnv::SymlinkToFile, true},
+    };
+    for (auto& TC : testCases) {
+        std::error_code ec;
+        TEST_CHECK(equivalent(TC.lhs, TC.rhs, ec) == TC.expect);
+        TEST_CHECK(!ec);
+    }
+}
+
+TEST_CASE(equivalent_reports_double_dne)
+{
+    const path E = StaticEnv::File;
+    const path DNE = StaticEnv::DNE;
+    { // Test that no exception is thrown if one of the paths exists
+        TEST_CHECK(equivalent(E, DNE) == false);
+        TEST_CHECK(equivalent(DNE, E) == false);
+    }
+    { // Test that an exception is thrown if both paths do not exist.
+        TEST_CHECK_THROW(filesystem_error, equivalent(DNE, DNE));
+    }
+    {
+        std::error_code ec;
+        TEST_CHECK(equivalent(DNE, DNE, ec) == false);
+        TEST_CHECK(ec);
+    }
+}
+
+TEST_CASE(equivalent_is_other_succeeds)
+{
+    scoped_test_env env;
+    path const file = env.create_file("file", 42);
+    const path hl1 = env.create_hardlink(file, "hl1");
+    const path hl2 = env.create_hardlink(file, "hl2");
+    TEST_CHECK(equivalent(file, hl1));
+    TEST_CHECK(equivalent(file, hl2));
+    TEST_CHECK(equivalent(hl1, hl2));
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.exists/exists.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.exists/exists.pass.cpp
new file mode 100644
index 000000000000..252ced6fd65f
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.exists/exists.pass.cpp
@@ -0,0 +1,88 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// bool exists(file_status s) noexcept
+// bool exists(path const& p);
+// bool exists(path const& p, std::error_code& ec) noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+
+TEST_SUITE(exists_test_suite)
+
+TEST_CASE(signature_test)
+{
+    file_status s; ((void)s);
+    const path p; ((void)p);
+    std::error_code ec; ((void)ec);
+    ASSERT_NOEXCEPT(exists(s));
+    ASSERT_NOEXCEPT(exists(p, ec));
+    ASSERT_NOT_NOEXCEPT(exists(p));
+}
+
+TEST_CASE(exists_status_test)
+{
+    struct TestCase {
+        file_type type;
+        bool expect;
+    };
+    const TestCase testCases[] = {
+        {file_type::none, false},
+        {file_type::not_found, false},
+        {file_type::regular, true},
+        {file_type::directory, true},
+        {file_type::symlink, true},
+        {file_type::block, true},
+        {file_type::character, true},
+        {file_type::fifo, true},
+        {file_type::socket, true},
+        {file_type::unknown, true}
+    };
+    for (auto& TC : testCases) {
+        file_status s(TC.type);
+        TEST_CHECK(exists(s) == TC.expect);
+    }
+}
+
+TEST_CASE(test_exist_not_found)
+{
+    const path p = StaticEnv::DNE;
+    TEST_CHECK(exists(p) == false);
+
+    std::error_code ec = GetTestEC();
+    TEST_CHECK(exists(p, ec) == false);
+    TEST_CHECK(!ec);
+}
+
+TEST_CASE(test_exists_fails)
+{
+    scoped_test_env env;
+    const path dir = env.create_dir("dir");
+    const path file = env.create_file("dir/file", 42);
+    permissions(dir, perms::none);
+
+    std::error_code ec;
+    TEST_CHECK(exists(file, ec) == false);
+    TEST_CHECK(ec);
+
+    TEST_CHECK_THROW(filesystem_error, exists(file));
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.file_size/file_size.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.file_size/file_size.pass.cpp
new file mode 100644
index 000000000000..460e42dd1c3f
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.file_size/file_size.pass.cpp
@@ -0,0 +1,79 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// uintmax_t file_size(const path& p);
+// uintmax_t file_size(const path& p, std::error_code& ec) noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+
+TEST_SUITE(file_size_test_suite)
+
+TEST_CASE(signature_test)
+{
+    const path p; ((void)p);
+    std::error_code ec; ((void)ec);
+    ASSERT_SAME_TYPE(decltype(file_size(p)), uintmax_t);
+    ASSERT_SAME_TYPE(decltype(file_size(p, ec)), uintmax_t);
+    ASSERT_NOT_NOEXCEPT(file_size(p));
+    ASSERT_NOEXCEPT(file_size(p, ec));
+}
+
+TEST_CASE(file_size_empty_test)
+{
+    const path p = StaticEnv::EmptyFile;
+    TEST_CHECK(file_size(p) == 0);
+    std::error_code ec;
+    TEST_CHECK(file_size(p, ec) == 0);
+}
+
+TEST_CASE(file_size_non_empty)
+{
+    scoped_test_env env;
+    const path p = env.create_file("file", 42);
+    TEST_CHECK(file_size(p) == 42);
+    std::error_code ec;
+    TEST_CHECK(file_size(p, ec) == 42);
+}
+
+TEST_CASE(symlink_test_case)
+{
+    const path p = StaticEnv::File;
+    const path p2 = StaticEnv::SymlinkToFile;
+    TEST_CHECK(file_size(p) == file_size(p2));
+}
+
+TEST_CASE(file_size_error_cases)
+{
+    const path testCases[] = {
+        StaticEnv::Dir,
+        StaticEnv::SymlinkToDir,
+        StaticEnv::BadSymlink,
+        StaticEnv::DNE
+    };
+    const uintmax_t expect = static_cast<uintmax_t>(-1);
+    for (auto& TC : testCases) {
+        std::error_code ec;
+        TEST_CHECK(file_size(TC, ec) == expect);
+        TEST_CHECK(ec);
+    }
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.hard_lk_ct/hard_link_count.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.hard_lk_ct/hard_link_count.pass.cpp
new file mode 100644
index 000000000000..abc50e9c6a41
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.hard_lk_ct/hard_link_count.pass.cpp
@@ -0,0 +1,86 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// uintmax_t hard_link_count(const path& p);
+// uintmax_t hard_link_count(const path& p, std::error_code& ec) noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+
+TEST_SUITE(hard_link_count_test_suite)
+
+TEST_CASE(signature_test)
+{
+    const path p; ((void)p);
+    std::error_code ec; ((void)ec);
+    ASSERT_SAME_TYPE(decltype(hard_link_count(p)), uintmax_t);
+    ASSERT_SAME_TYPE(decltype(hard_link_count(p, ec)), uintmax_t);
+    ASSERT_NOT_NOEXCEPT(hard_link_count(p));
+    ASSERT_NOEXCEPT(hard_link_count(p, ec));
+}
+
+TEST_CASE(hard_link_count_for_file)
+{
+    TEST_CHECK(hard_link_count(StaticEnv::File) == 1);
+    std::error_code ec;
+    TEST_CHECK(hard_link_count(StaticEnv::File, ec) == 1);
+}
+
+TEST_CASE(hard_link_count_for_directory)
+{
+    uintmax_t DirExpect = 3;
+    uintmax_t Dir3Expect = 2;
+#if defined(__APPLE__)
+    DirExpect += 2;
+    Dir3Expect += 1;
+#endif
+    TEST_CHECK(hard_link_count(StaticEnv::Dir) == DirExpect);
+    TEST_CHECK(hard_link_count(StaticEnv::Dir3) == Dir3Expect);
+
+    std::error_code ec;
+    TEST_CHECK(hard_link_count(StaticEnv::Dir, ec) == DirExpect);
+    TEST_CHECK(hard_link_count(StaticEnv::Dir3, ec) == Dir3Expect);
+}
+TEST_CASE(hard_link_count_increments_test)
+{
+    scoped_test_env env;
+    const path file = env.create_file("file", 42);
+    TEST_CHECK(hard_link_count(file) == 1);
+
+    env.create_hardlink(file, "file_hl");
+    TEST_CHECK(hard_link_count(file) == 2);
+}
+
+
+TEST_CASE(hard_link_count_error_cases)
+{
+    const path testCases[] = {
+        StaticEnv::BadSymlink,
+        StaticEnv::DNE
+    };
+    const uintmax_t expect = static_cast<uintmax_t>(-1);
+    for (auto& TC : testCases) {
+        std::error_code ec;
+        TEST_CHECK(hard_link_count(TC, ec) == expect);
+        TEST_CHECK(ec);
+    }
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.is_block_file/is_block_file.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.is_block_file/is_block_file.pass.cpp
new file mode 100644
index 000000000000..dee28aa5be61
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.is_block_file/is_block_file.pass.cpp
@@ -0,0 +1,84 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// bool is_block_file(file_status s) noexcept
+// bool is_block_file(path const& p);
+// bool is_block_file(path const& p, std::error_code& ec) noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+
+TEST_SUITE(is_block_file_test_suite)
+
+TEST_CASE(signature_test)
+{
+    file_status s; ((void)s);
+    const path p; ((void)p);
+    std::error_code ec; ((void)ec);
+    ASSERT_NOEXCEPT(is_block_file(s));
+    ASSERT_NOEXCEPT(is_block_file(p, ec));
+    ASSERT_NOT_NOEXCEPT(is_block_file(p));
+}
+
+TEST_CASE(is_block_file_status_test)
+{
+    struct TestCase {
+        file_type type;
+        bool expect;
+    };
+    const TestCase testCases[] = {
+        {file_type::none, false},
+        {file_type::not_found, false},
+        {file_type::regular, false},
+        {file_type::directory, false},
+        {file_type::symlink, false},
+        {file_type::block, true},
+        {file_type::character, false},
+        {file_type::fifo, false},
+        {file_type::socket, false},
+        {file_type::unknown, false}
+    };
+    for (auto& TC : testCases) {
+        file_status s(TC.type);
+        TEST_CHECK(is_block_file(s) == TC.expect);
+    }
+}
+
+TEST_CASE(test_exist_not_found)
+{
+    const path p = StaticEnv::DNE;
+    TEST_CHECK(is_block_file(p) == false);
+}
+
+TEST_CASE(test_is_block_file_fails)
+{
+    scoped_test_env env;
+    const path dir = env.create_dir("dir");
+    const path file = env.create_file("dir/file", 42);
+    permissions(dir, perms::none);
+
+    std::error_code ec;
+    TEST_CHECK(is_block_file(file, ec) == false);
+    TEST_CHECK(ec);
+
+    TEST_CHECK_THROW(filesystem_error, is_block_file(file));
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.is_char_file/is_character_file.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.is_char_file/is_character_file.pass.cpp
new file mode 100644
index 000000000000..2de42bf20975
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.is_char_file/is_character_file.pass.cpp
@@ -0,0 +1,84 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// bool is_character_file(file_status s) noexcept
+// bool is_character_file(path const& p);
+// bool is_character_file(path const& p, std::error_code& ec) noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+
+TEST_SUITE(is_character_file_test_suite)
+
+TEST_CASE(signature_test)
+{
+    file_status s; ((void)s);
+    const path p; ((void)p);
+    std::error_code ec; ((void)ec);
+    ASSERT_NOEXCEPT(is_character_file(s));
+    ASSERT_NOEXCEPT(is_character_file(p, ec));
+    ASSERT_NOT_NOEXCEPT(is_character_file(p));
+}
+
+TEST_CASE(is_character_file_status_test)
+{
+    struct TestCase {
+        file_type type;
+        bool expect;
+    };
+    const TestCase testCases[] = {
+        {file_type::none, false},
+        {file_type::not_found, false},
+        {file_type::regular, false},
+        {file_type::directory, false},
+        {file_type::symlink, false},
+        {file_type::block, false},
+        {file_type::character, true},
+        {file_type::fifo, false},
+        {file_type::socket, false},
+        {file_type::unknown, false}
+    };
+    for (auto& TC : testCases) {
+        file_status s(TC.type);
+        TEST_CHECK(is_character_file(s) == TC.expect);
+    }
+}
+
+TEST_CASE(test_exist_not_found)
+{
+    const path p = StaticEnv::DNE;
+    TEST_CHECK(is_character_file(p) == false);
+}
+
+TEST_CASE(test_is_character_file_fails)
+{
+    scoped_test_env env;
+    const path dir = env.create_dir("dir");
+    const path file = env.create_file("dir/file", 42);
+    permissions(dir, perms::none);
+
+    std::error_code ec;
+    TEST_CHECK(is_character_file(file, ec) == false);
+    TEST_CHECK(ec);
+
+    TEST_CHECK_THROW(filesystem_error, is_character_file(file));
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.is_directory/is_directory.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.is_directory/is_directory.pass.cpp
new file mode 100644
index 000000000000..d6ecb1a1e684
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.is_directory/is_directory.pass.cpp
@@ -0,0 +1,91 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// bool is_directory(file_status s) noexcept
+// bool is_directory(path const& p);
+// bool is_directory(path const& p, std::error_code& ec) noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+
+TEST_SUITE(is_directory_test_suite)
+
+TEST_CASE(signature_test)
+{
+    file_status s; ((void)s);
+    const path p; ((void)p);
+    std::error_code ec; ((void)ec);
+    ASSERT_NOEXCEPT(is_directory(s));
+    ASSERT_NOEXCEPT(is_directory(p, ec));
+    ASSERT_NOT_NOEXCEPT(is_directory(p));
+}
+
+TEST_CASE(is_directory_status_test)
+{
+    struct TestCase {
+        file_type type;
+        bool expect;
+    };
+    const TestCase testCases[] = {
+        {file_type::none, false},
+        {file_type::not_found, false},
+        {file_type::regular, false},
+        {file_type::directory, true},
+        {file_type::symlink, false},
+        {file_type::block, false},
+        {file_type::character, false},
+        {file_type::fifo, false},
+        {file_type::socket, false},
+        {file_type::unknown, false}
+    };
+    for (auto& TC : testCases) {
+        file_status s(TC.type);
+        TEST_CHECK(is_directory(s) == TC.expect);
+    }
+}
+
+TEST_CASE(test_exist_not_found)
+{
+    const path p = StaticEnv::DNE;
+    TEST_CHECK(is_directory(p) == false);
+}
+
+TEST_CASE(static_env_test)
+{
+    TEST_CHECK(is_directory(StaticEnv::Dir));
+    TEST_CHECK(is_directory(StaticEnv::SymlinkToDir));
+    TEST_CHECK(!is_directory(StaticEnv::File));
+}
+
+TEST_CASE(test_is_directory_fails)
+{
+    scoped_test_env env;
+    const path dir = env.create_dir("dir");
+    const path dir2 = env.create_dir("dir/dir2");
+    permissions(dir, perms::none);
+
+    std::error_code ec;
+    TEST_CHECK(is_directory(dir2, ec) == false);
+    TEST_CHECK(ec);
+
+    TEST_CHECK_THROW(filesystem_error, is_directory(dir2));
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.is_empty/is_empty.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.is_empty/is_empty.pass.cpp
new file mode 100644
index 000000000000..ba07d09d10d9
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.is_empty/is_empty.pass.cpp
@@ -0,0 +1,80 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// bool is_empty(path const& p);
+// bool is_empty(path const& p, std::error_code& ec) noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+
+TEST_SUITE(is_empty_test_suite)
+
+TEST_CASE(signature_test)
+{
+    const path p; ((void)p);
+    std::error_code ec; ((void)ec);
+    ASSERT_NOEXCEPT(is_empty(p, ec));
+    ASSERT_NOT_NOEXCEPT(is_empty(p));
+}
+
+TEST_CASE(test_exist_not_found)
+{
+    const path p = StaticEnv::DNE;
+    std::error_code ec;
+    TEST_CHECK(is_empty(p, ec) == false);
+    TEST_CHECK(ec);
+    TEST_CHECK_THROW(filesystem_error, is_empty(p));
+}
+
+TEST_CASE(test_is_empty_directory)
+{
+    TEST_CHECK(!is_empty(StaticEnv::Dir));
+    TEST_CHECK(!is_empty(StaticEnv::SymlinkToDir));
+}
+
+TEST_CASE(test_is_empty_directory_dynamic)
+{
+    scoped_test_env env;
+    TEST_CHECK(is_empty(env.test_root));
+    env.create_file("foo", 42);
+    TEST_CHECK(!is_empty(env.test_root));
+}
+
+TEST_CASE(test_is_empty_file)
+{
+    TEST_CHECK(is_empty(StaticEnv::EmptyFile));
+    TEST_CHECK(!is_empty(StaticEnv::NonEmptyFile));
+}
+
+TEST_CASE(test_is_empty_fails)
+{
+    scoped_test_env env;
+    const path dir = env.create_dir("dir");
+    const path dir2 = env.create_dir("dir/dir2");
+    permissions(dir, perms::none);
+
+    std::error_code ec;
+    TEST_CHECK(is_empty(dir2, ec) == false);
+    TEST_CHECK(ec);
+
+    TEST_CHECK_THROW(filesystem_error, is_empty(dir2));
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.is_fifo/is_fifo.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.is_fifo/is_fifo.pass.cpp
new file mode 100644
index 000000000000..44892f65d86e
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.is_fifo/is_fifo.pass.cpp
@@ -0,0 +1,84 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// bool is_fifo(file_status s) noexcept
+// bool is_fifo(path const& p);
+// bool is_fifo(path const& p, std::error_code& ec) noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+
+TEST_SUITE(is_fifo_test_suite)
+
+TEST_CASE(signature_test)
+{
+    file_status s; ((void)s);
+    const path p; ((void)p);
+    std::error_code ec; ((void)ec);
+    ASSERT_NOEXCEPT(is_fifo(s));
+    ASSERT_NOEXCEPT(is_fifo(p, ec));
+    ASSERT_NOT_NOEXCEPT(is_fifo(p));
+}
+
+TEST_CASE(is_fifo_status_test)
+{
+    struct TestCase {
+        file_type type;
+        bool expect;
+    };
+    const TestCase testCases[] = {
+        {file_type::none, false},
+        {file_type::not_found, false},
+        {file_type::regular, false},
+        {file_type::directory, false},
+        {file_type::symlink, false},
+        {file_type::block, false},
+        {file_type::character, false},
+        {file_type::fifo, true},
+        {file_type::socket, false},
+        {file_type::unknown, false}
+    };
+    for (auto& TC : testCases) {
+        file_status s(TC.type);
+        TEST_CHECK(is_fifo(s) == TC.expect);
+    }
+}
+
+TEST_CASE(test_exist_not_found)
+{
+    const path p = StaticEnv::DNE;
+    TEST_CHECK(is_fifo(p) == false);
+}
+
+TEST_CASE(test_is_fifo_fails)
+{
+    scoped_test_env env;
+    const path dir = env.create_dir("dir");
+    const path file = env.create_file("dir/file", 42);
+    permissions(dir, perms::none);
+
+    std::error_code ec;
+    TEST_CHECK(is_fifo(file, ec) == false);
+    TEST_CHECK(ec);
+
+    TEST_CHECK_THROW(filesystem_error, is_fifo(file));
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.is_other/is_other.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.is_other/is_other.pass.cpp
new file mode 100644
index 000000000000..e86b66b4ea64
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.is_other/is_other.pass.cpp
@@ -0,0 +1,84 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// bool is_other(file_status s) noexcept
+// bool is_other(path const& p);
+// bool is_other(path const& p, std::error_code& ec) noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+
+TEST_SUITE(is_other_test_suite)
+
+TEST_CASE(signature_test)
+{
+    file_status s; ((void)s);
+    const path p; ((void)p);
+    std::error_code ec; ((void)ec);
+    ASSERT_NOEXCEPT(is_other(s));
+    ASSERT_NOEXCEPT(is_other(p, ec));
+    ASSERT_NOT_NOEXCEPT(is_other(p));
+}
+
+TEST_CASE(is_other_status_test)
+{
+    struct TestCase {
+        file_type type;
+        bool expect;
+    };
+    const TestCase testCases[] = {
+        {file_type::none, false},
+        {file_type::not_found, false},
+        {file_type::regular, false},
+        {file_type::directory, false},
+        {file_type::symlink, false},
+        {file_type::block, true},
+        {file_type::character, true},
+        {file_type::fifo, true},
+        {file_type::socket, true},
+        {file_type::unknown, true}
+    };
+    for (auto& TC : testCases) {
+        file_status s(TC.type);
+        TEST_CHECK(is_other(s) == TC.expect);
+    }
+}
+
+TEST_CASE(test_exist_not_found)
+{
+    const path p = StaticEnv::DNE;
+    TEST_CHECK(is_other(p) == false);
+}
+
+TEST_CASE(test_is_other_fails)
+{
+    scoped_test_env env;
+    const path dir = env.create_dir("dir");
+    const path file = env.create_file("dir/file", 42);
+    permissions(dir, perms::none);
+
+    std::error_code ec;
+    TEST_CHECK(is_other(file, ec) == false);
+    TEST_CHECK(ec);
+
+    TEST_CHECK_THROW(filesystem_error, is_other(file));
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.is_regular_file/is_regular_file.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.is_regular_file/is_regular_file.pass.cpp
new file mode 100644
index 000000000000..be68dcfc35de
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.is_regular_file/is_regular_file.pass.cpp
@@ -0,0 +1,87 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// bool is_regular_file(file_status s) noexcept
+// bool is_regular_file(path const& p);
+// bool is_regular_file(path const& p, std::error_code& ec) noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+
+TEST_SUITE(is_regular_file_test_suite)
+
+TEST_CASE(signature_test)
+{
+    file_status s; ((void)s);
+    const path p; ((void)p);
+    std::error_code ec; ((void)ec);
+    ASSERT_NOEXCEPT(is_regular_file(s));
+    ASSERT_NOEXCEPT(is_regular_file(p, ec));
+    ASSERT_NOT_NOEXCEPT(is_regular_file(p));
+}
+
+TEST_CASE(is_regular_file_status_test)
+{
+    struct TestCase {
+        file_type type;
+        bool expect;
+    };
+    const TestCase testCases[] = {
+        {file_type::none, false},
+        {file_type::not_found, false},
+        {file_type::regular, true},
+        {file_type::directory, false},
+        {file_type::symlink, false},
+        {file_type::block, false},
+        {file_type::character, false},
+        {file_type::fifo, false},
+        {file_type::socket, false},
+        {file_type::unknown, false}
+    };
+    for (auto& TC : testCases) {
+        file_status s(TC.type);
+        TEST_CHECK(is_regular_file(s) == TC.expect);
+    }
+}
+
+TEST_CASE(test_exist_not_found)
+{
+    const path p = StaticEnv::DNE;
+    TEST_CHECK(is_regular_file(p) == false);
+    std::error_code ec;
+    TEST_CHECK(is_regular_file(p, ec) == false);
+    TEST_CHECK(ec);
+}
+
+TEST_CASE(test_is_regular_file_fails)
+{
+    scoped_test_env env;
+    const path dir = env.create_dir("dir");
+    const path file = env.create_file("dir/file", 42);
+    permissions(dir, perms::none);
+
+    std::error_code ec;
+    TEST_CHECK(is_regular_file(file, ec) == false);
+    TEST_CHECK(ec);
+
+    TEST_CHECK_THROW(filesystem_error, is_regular_file(file));
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.is_socket/is_socket.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.is_socket/is_socket.pass.cpp
new file mode 100644
index 000000000000..49fd402eb546
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.is_socket/is_socket.pass.cpp
@@ -0,0 +1,84 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// bool is_socket(file_status s) noexcept
+// bool is_socket(path const& p);
+// bool is_socket(path const& p, std::error_code& ec) noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+
+TEST_SUITE(is_socket_test_suite)
+
+TEST_CASE(signature_test)
+{
+    file_status s; ((void)s);
+    const path p; ((void)p);
+    std::error_code ec; ((void)ec);
+    ASSERT_NOEXCEPT(is_socket(s));
+    ASSERT_NOEXCEPT(is_socket(p, ec));
+    ASSERT_NOT_NOEXCEPT(is_socket(p));
+}
+
+TEST_CASE(is_socket_status_test)
+{
+    struct TestCase {
+        file_type type;
+        bool expect;
+    };
+    const TestCase testCases[] = {
+        {file_type::none, false},
+        {file_type::not_found, false},
+        {file_type::regular, false},
+        {file_type::directory, false},
+        {file_type::symlink, false},
+        {file_type::block, false},
+        {file_type::character, false},
+        {file_type::fifo, false},
+        {file_type::socket, true},
+        {file_type::unknown, false}
+    };
+    for (auto& TC : testCases) {
+        file_status s(TC.type);
+        TEST_CHECK(is_socket(s) == TC.expect);
+    }
+}
+
+TEST_CASE(test_exist_not_found)
+{
+    const path p = StaticEnv::DNE;
+    TEST_CHECK(is_socket(p) == false);
+}
+
+TEST_CASE(test_is_socket_fails)
+{
+    scoped_test_env env;
+    const path dir = env.create_dir("dir");
+    const path file = env.create_file("dir/file", 42);
+    permissions(dir, perms::none);
+
+    std::error_code ec;
+    TEST_CHECK(is_socket(file, ec) == false);
+    TEST_CHECK(ec);
+
+    TEST_CHECK_THROW(filesystem_error, is_socket(file));
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.is_symlink/is_symlink.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.is_symlink/is_symlink.pass.cpp
new file mode 100644
index 000000000000..3de002978683
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.is_symlink/is_symlink.pass.cpp
@@ -0,0 +1,105 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// bool is_symlink(file_status s) noexcept
+// bool is_symlink(path const& p);
+// bool is_symlink(path const& p, std::error_code& ec) noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+
+TEST_SUITE(is_symlink_test_suite)
+
+TEST_CASE(signature_test)
+{
+    file_status s; ((void)s);
+    const path p; ((void)p);
+    std::error_code ec; ((void)ec);
+    ASSERT_NOEXCEPT(is_symlink(s));
+    ASSERT_NOEXCEPT(is_symlink(p, ec));
+    ASSERT_NOT_NOEXCEPT(is_symlink(p));
+}
+
+TEST_CASE(is_symlink_status_test)
+{
+    struct TestCase {
+        file_type type;
+        bool expect;
+    };
+    const TestCase testCases[] = {
+        {file_type::none, false},
+        {file_type::not_found, false},
+        {file_type::regular, false},
+        {file_type::directory, false},
+        {file_type::symlink, true},
+        {file_type::block, false},
+        {file_type::character, false},
+        {file_type::fifo, false},
+        {file_type::socket, false},
+        {file_type::unknown, false}
+    };
+    for (auto& TC : testCases) {
+        file_status s(TC.type);
+        TEST_CHECK(is_symlink(s) == TC.expect);
+    }
+}
+
+TEST_CASE(static_env_test)
+{
+    struct TestCase {
+        path p;
+        bool expect;
+    };
+    const TestCase testCases[] = {
+        {StaticEnv::File, false},
+        {StaticEnv::Dir, false},
+        {StaticEnv::SymlinkToFile, true},
+        {StaticEnv::SymlinkToDir, true},
+        {StaticEnv::BadSymlink, true}
+    };
+    for (auto& TC : testCases) {
+        TEST_CHECK(is_symlink(TC.p) == TC.expect);
+    }
+}
+
+TEST_CASE(test_exist_not_found)
+{
+    const path p = StaticEnv::DNE;
+    TEST_CHECK(is_symlink(p) == false);
+    std::error_code ec;
+    TEST_CHECK(is_symlink(p, ec) == false);
+    TEST_CHECK(ec);
+}
+
+TEST_CASE(test_is_symlink_fails)
+{
+    scoped_test_env env;
+    const path dir = env.create_dir("dir");
+    const path file = env.create_file("dir/file", 42);
+    permissions(dir, perms::none);
+
+    std::error_code ec;
+    TEST_CHECK(is_symlink(file, ec) == false);
+    TEST_CHECK(ec);
+
+    TEST_CHECK_THROW(filesystem_error, is_symlink(file));
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
new file mode 100644
index 000000000000..3c61b26d18e0
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
@@ -0,0 +1,361 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// file_time_type last_write_time(const path& p);
+// file_time_type last_write_time(const path& p, std::error_code& ec) noexcept;
+// void last_write_time(const path& p, file_time_type new_time);
+// void last_write_time(const path& p, file_time_type new_type,
+//                      std::error_code& ec) noexcept;
+
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <chrono>
+#include <fstream>
+#include <cstdlib>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+#include <sys/stat.h>
+#include <iostream>
+
+using namespace std::experimental::filesystem;
+
+
+std::pair<std::time_t, std::time_t> GetTimes(path const& p) {
+    using Clock = file_time_type::clock;
+    struct ::stat st;
+    if (::stat(p.c_str(), &st) == -1) {
+        std::error_code ec(errno, std::generic_category());
+#ifndef TEST_HAS_NO_EXCEPTIONS
+        throw ec;
+#else
+        std::cerr << ec.message() << std::endl;
+        std::exit(EXIT_FAILURE);
+#endif
+    }
+    return {st.st_atime, st.st_mtime};
+}
+
+std::time_t LastAccessTime(path const& p) {
+    return GetTimes(p).first;
+}
+
+std::time_t LastWriteTime(path const& p) {
+    return GetTimes(p).second;
+}
+
+std::pair<std::time_t, std::time_t> GetSymlinkTimes(path const& p) {
+    using Clock = file_time_type::clock;
+    struct ::stat st;
+    if (::lstat(p.c_str(), &st) == -1) {
+        std::error_code ec(errno, std::generic_category());
+#ifndef TEST_HAS_NO_EXCEPTIONS
+        throw ec;
+#else
+        std::cerr << ec.message() << std::endl;
+        std::exit(EXIT_FAILURE);
+#endif
+    }
+    return {st.st_atime, st.st_mtime};
+}
+
+inline bool TimeIsRepresentableAsTimeT(file_time_type tp) {
+    using namespace std::chrono;
+    using Lim = std::numeric_limits<std::time_t>;
+    auto sec = duration_cast<seconds>(tp.time_since_epoch()).count();
+    return (sec >= Lim::min() && sec <= Lim::max());
+}
+
+
+TEST_SUITE(exists_test_suite)
+
+TEST_CASE(signature_test)
+{
+    const file_time_type t;
+    const path p; ((void)p);
+    std::error_code ec; ((void)ec);
+    ASSERT_SAME_TYPE(decltype(last_write_time(p)), file_time_type);
+    ASSERT_SAME_TYPE(decltype(last_write_time(p, ec)), file_time_type);
+    ASSERT_SAME_TYPE(decltype(last_write_time(p, t)), void);
+    ASSERT_SAME_TYPE(decltype(last_write_time(p, t, ec)), void);
+    ASSERT_NOT_NOEXCEPT(last_write_time(p));
+    ASSERT_NOT_NOEXCEPT(last_write_time(p, t));
+    ASSERT_NOEXCEPT(last_write_time(p, ec));
+    ASSERT_NOEXCEPT(last_write_time(p, t, ec));
+}
+
+TEST_CASE(read_last_write_time_static_env_test)
+{
+    using C = file_time_type::clock;
+    file_time_type min = file_time_type::min();
+    {
+        file_time_type ret = last_write_time(StaticEnv::File);
+        TEST_CHECK(ret != min);
+        TEST_CHECK(ret < C::now());
+        TEST_CHECK(C::to_time_t(ret) == LastWriteTime(StaticEnv::File));
+
+        file_time_type ret2 = last_write_time(StaticEnv::SymlinkToFile);
+        TEST_CHECK(ret == ret2);
+        TEST_CHECK(C::to_time_t(ret2) == LastWriteTime(StaticEnv::SymlinkToFile));
+    }
+    {
+        file_time_type ret = last_write_time(StaticEnv::Dir);
+        TEST_CHECK(ret != min);
+        TEST_CHECK(ret < C::now());
+        TEST_CHECK(C::to_time_t(ret) == LastWriteTime(StaticEnv::Dir));
+
+        file_time_type ret2 = last_write_time(StaticEnv::SymlinkToDir);
+        TEST_CHECK(ret == ret2);
+        TEST_CHECK(C::to_time_t(ret2) == LastWriteTime(StaticEnv::SymlinkToDir));
+    }
+}
+
+TEST_CASE(get_last_write_time_dynamic_env_test)
+{
+    using Clock = file_time_type::clock;
+    using Sec = std::chrono::seconds;
+    scoped_test_env env;
+
+    const path file = env.create_file("file", 42);
+    const path dir = env.create_dir("dir");
+
+    const auto file_times = GetTimes(file);
+    const std::time_t file_access_time = file_times.first;
+    const std::time_t file_write_time = file_times.second;
+    const auto dir_times = GetTimes(dir);
+    const std::time_t dir_access_time = dir_times.first;
+    const std::time_t dir_write_time = dir_times.second;
+
+    file_time_type ftime = last_write_time(file);
+    TEST_CHECK(Clock::to_time_t(ftime) == file_write_time);
+
+    file_time_type dtime = last_write_time(dir);
+    TEST_CHECK(Clock::to_time_t(dtime) == dir_write_time);
+
+    SleepFor(Sec(2));
+
+    // update file and add a file to the directory. Make sure the times increase.
+    std::ofstream of(file, std::ofstream::app);
+    of << "hello";
+    of.close();
+    env.create_file("dir/file1", 1);
+
+    file_time_type ftime2 = last_write_time(file);
+    file_time_type dtime2 = last_write_time(dir);
+
+    TEST_CHECK(ftime2 > ftime);
+    TEST_CHECK(dtime2 > dtime);
+    TEST_CHECK(LastAccessTime(file) == file_access_time);
+    TEST_CHECK(LastAccessTime(dir) == dir_access_time);
+}
+
+
+TEST_CASE(set_last_write_time_dynamic_env_test)
+{
+    using Clock = file_time_type::clock;
+    using Sec = std::chrono::seconds;
+    using Hours = std::chrono::hours;
+    using Minutes = std::chrono::minutes;
+    using MicroSec = std::chrono::microseconds;
+    scoped_test_env env;
+
+    const path file = env.create_file("file", 42);
+    const path dir = env.create_dir("dir");
+    const auto now = Clock::now();
+    const file_time_type epoch_time = now - now.time_since_epoch();
+
+    const file_time_type future_time = now + Hours(3) + Sec(42) + MicroSec(17);
+    const file_time_type past_time = now - Minutes(3) - Sec(42) - MicroSec(17);
+    const file_time_type before_epoch_time = epoch_time - Minutes(3) - Sec(42) - MicroSec(17);
+    // FreeBSD has a bug in their utimes implementation where the time is not update
+    // when the number of seconds is '-1'.
+#if defined(__FreeBSD__)
+    const file_time_type just_before_epoch_time = epoch_time - Sec(2) - MicroSec(17);
+#else
+    const file_time_type just_before_epoch_time = epoch_time - MicroSec(17);
+#endif
+
+    struct TestCase {
+      path p;
+      file_time_type new_time;
+    } cases[] = {
+        {file, epoch_time},
+        {dir, epoch_time},
+        {file, future_time},
+        {dir, future_time},
+        {file, past_time},
+        {dir, past_time},
+        {file, before_epoch_time},
+        {dir, before_epoch_time},
+        {file, just_before_epoch_time},
+        {dir, just_before_epoch_time}
+    };
+    for (const auto& TC : cases) {
+        const auto old_times = GetTimes(TC.p);
+        file_time_type old_time(Sec(old_times.second));
+
+        std::error_code ec = GetTestEC();
+        last_write_time(TC.p, TC.new_time, ec);
+        TEST_CHECK(!ec);
+
+        file_time_type  got_time = last_write_time(TC.p);
+
+        TEST_CHECK(got_time != old_time);
+        if (TC.new_time < epoch_time) {
+            TEST_CHECK(got_time <= TC.new_time);
+            TEST_CHECK(got_time > TC.new_time - Sec(1));
+        } else {
+            TEST_CHECK(got_time <= TC.new_time + Sec(1));
+            TEST_CHECK(got_time >= TC.new_time - Sec(1));
+        }
+        TEST_CHECK(LastAccessTime(TC.p) == old_times.first);
+    }
+}
+
+TEST_CASE(last_write_time_symlink_test)
+{
+    using Clock = file_time_type::clock;
+    using Sec = std::chrono::seconds;
+    using Hours = std::chrono::hours;
+    using Minutes = std::chrono::minutes;
+
+    scoped_test_env env;
+
+    const path file = env.create_file("file", 42);
+    const path sym = env.create_symlink("file", "sym");
+
+    const file_time_type new_time = Clock::now() + Hours(3);
+
+    const auto old_times = GetTimes(sym);
+    const auto old_sym_times = GetSymlinkTimes(sym);
+
+    std::error_code ec = GetTestEC();
+    last_write_time(sym, new_time, ec);
+    TEST_CHECK(!ec);
+
+    const std::time_t new_time_t = Clock::to_time_t(new_time);
+    file_time_type  got_time = last_write_time(sym);
+    std::time_t got_time_t = Clock::to_time_t(got_time);
+
+    TEST_CHECK(got_time_t != old_times.second);
+    TEST_CHECK(got_time_t == new_time_t);
+    TEST_CHECK(LastWriteTime(file) == new_time_t);
+    TEST_CHECK(LastAccessTime(sym) == old_times.first);
+    TEST_CHECK(GetSymlinkTimes(sym) == old_sym_times);
+}
+
+
+TEST_CASE(test_write_min_time)
+{
+    using Clock = file_time_type::clock;
+    using Sec = std::chrono::seconds;
+    using MicroSec = std::chrono::microseconds;
+    using Lim = std::numeric_limits<std::time_t>;
+    scoped_test_env env;
+    const path p = env.create_file("file", 42);
+
+    std::error_code ec = GetTestEC();
+    file_time_type last_time = last_write_time(p);
+    file_time_type new_time = file_time_type::min();
+
+    last_write_time(p, new_time, ec);
+    file_time_type tt = last_write_time(p);
+
+    if (!TimeIsRepresentableAsTimeT(new_time)) {
+        TEST_CHECK(ec);
+        TEST_CHECK(ec != GetTestEC());
+        TEST_CHECK(tt == last_time);
+    } else {
+        TEST_CHECK(!ec);
+        TEST_CHECK(tt >= new_time);
+        TEST_CHECK(tt < new_time + Sec(1));
+    }
+
+    ec = GetTestEC();
+    last_write_time(p, Clock::now());
+    last_time = last_write_time(p);
+
+    new_time = file_time_type::min() + MicroSec(1);
+
+    last_write_time(p, new_time, ec);
+    tt = last_write_time(p);
+
+    if (!TimeIsRepresentableAsTimeT(new_time)) {
+        TEST_CHECK(ec);
+        TEST_CHECK(ec != GetTestEC());
+        TEST_CHECK(tt == last_time);
+    } else {
+        TEST_CHECK(!ec);
+        TEST_CHECK(tt >= new_time);
+        TEST_CHECK(tt < new_time + Sec(1));
+    }
+}
+
+
+
+TEST_CASE(test_write_min_max_time)
+{
+    using Clock = file_time_type::clock;
+    using Sec = std::chrono::seconds;
+    using Hours = std::chrono::hours;
+    using Lim = std::numeric_limits<std::time_t>;
+    scoped_test_env env;
+    const path p = env.create_file("file", 42);
+
+    std::error_code ec = GetTestEC();
+    file_time_type last_time = last_write_time(p);
+    file_time_type new_time = file_time_type::max();
+
+    ec = GetTestEC();
+    last_write_time(p, new_time, ec);
+    file_time_type tt = last_write_time(p);
+
+    if (!TimeIsRepresentableAsTimeT(new_time)) {
+        TEST_CHECK(ec);
+        TEST_CHECK(ec != GetTestEC());
+        TEST_CHECK(tt == last_time);
+    } else {
+        TEST_CHECK(!ec);
+        TEST_CHECK(tt > new_time - Sec(1));
+        TEST_CHECK(tt <= new_time);
+    }
+}
+
+TEST_CASE(test_value_on_failure)
+{
+    const path p = StaticEnv::DNE;
+    std::error_code ec = GetTestEC();
+    TEST_CHECK(last_write_time(p, ec) == file_time_type::min());
+    TEST_CHECK(ec);
+    TEST_CHECK(ec != GetTestEC());
+}
+
+TEST_CASE(test_exists_fails)
+{
+    scoped_test_env env;
+    const path dir = env.create_dir("dir");
+    const path file = env.create_file("dir/file", 42);
+    permissions(dir, perms::none);
+
+    std::error_code ec = GetTestEC();
+    TEST_CHECK(last_write_time(file, ec) == file_time_type::min());
+    TEST_CHECK(ec);
+    TEST_CHECK(ec != GetTestEC());
+
+    TEST_CHECK_THROW(filesystem_error, last_write_time(file));
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.permissions/permissions.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.permissions/permissions.pass.cpp
new file mode 100644
index 000000000000..b177693c09bd
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.permissions/permissions.pass.cpp
@@ -0,0 +1,158 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// void permissions(const path& p, perms prms);
+// void permissions(const path& p, perms prms, std::error_code& ec) noexcept;
+
+
+#include <experimental/filesystem>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+namespace fs = std::experimental::filesystem;
+
+using PR = fs::perms;
+
+TEST_SUITE(filesystem_permissions_test_suite)
+
+TEST_CASE(test_signatures)
+{
+    const path p; ((void)p);
+    const perms opts{}; ((void)opts);
+    std::error_code ec; ((void)ec);
+    ASSERT_NOT_NOEXCEPT(fs::permissions(p, opts));
+    // Not noexcept because of narrow contract
+    ASSERT_NOT_NOEXCEPT(fs::permissions(p, opts, ec));
+}
+
+TEST_CASE(test_error_reporting)
+{
+    auto checkThrow = [](path const& f, fs::perms opts, const std::error_code& ec)
+    {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+        try {
+            fs::permissions(f, opts);
+            return false;
+        } catch (filesystem_error const& err) {
+            return err.path1() == f
+                && err.path2() == ""
+                && err.code() == ec;
+        }
+#else
+        return true;
+#endif
+    };
+
+    scoped_test_env env;
+    const path dne = env.make_env_path("dne");
+    const path dne_sym = env.create_symlink(dne, "dne_sym");
+    { // !exists
+        std::error_code ec;
+        fs::permissions(dne, fs::perms{}, ec);
+        TEST_REQUIRE(ec);
+        TEST_CHECK(checkThrow(dne, fs::perms{}, ec));
+    }
+    {
+        std::error_code ec;
+        fs::permissions(dne_sym, fs::perms{}, ec);
+        TEST_REQUIRE(ec);
+        TEST_CHECK(checkThrow(dne_sym, fs::perms{}, ec));
+    }
+}
+
+TEST_CASE(basic_permissions_test)
+{
+    scoped_test_env env;
+    const path file = env.create_file("file1", 42);
+    const path dir = env.create_dir("dir1");
+    const path file_for_sym = env.create_file("file2", 42);
+    const path sym = env.create_symlink(file_for_sym, "sym");
+    const perms AP = perms::add_perms;
+    const perms RP = perms::remove_perms;
+    const perms NF = perms::symlink_nofollow;
+    struct TestCase {
+      path p;
+      perms set_perms;
+      perms expected;
+    } cases[] = {
+        // test file
+        {file, perms::none, perms::none},
+        {file, perms::owner_all, perms::owner_all},
+        {file, perms::group_all | AP, perms::owner_all | perms::group_all},
+        {file, perms::group_all | RP, perms::owner_all},
+        // test directory
+        {dir, perms::none, perms::none},
+        {dir, perms::owner_all, perms::owner_all},
+        {dir, perms::group_all | AP, perms::owner_all | perms::group_all},
+        {dir, perms::group_all | RP, perms::owner_all},
+        // test symlink without symlink_nofollow
+        {sym, perms::none, perms::none},
+        {sym, perms::owner_all, perms::owner_all},
+        {sym, perms::group_all | AP, perms::owner_all | perms::group_all},
+        {sym, perms::group_all | RP , perms::owner_all},
+        // test non-symlink with symlink_nofollow. The last test on file/dir
+        // will have set their permissions to perms::owner_all
+        {file, perms::group_all | AP | NF, perms::owner_all | perms::group_all},
+        {dir,  perms::group_all | AP | NF, perms::owner_all | perms::group_all}
+    };
+    for (auto const& TC : cases) {
+        TEST_CHECK(status(TC.p).permissions() != TC.expected);
+        // Set the error code to ensure it's cleared.
+        std::error_code ec = std::make_error_code(std::errc::bad_address);
+        permissions(TC.p, TC.set_perms, ec);
+        TEST_CHECK(!ec);
+        auto pp = status(TC.p).permissions();
+        TEST_CHECK(status(TC.p).permissions() == TC.expected);
+    }
+}
+
+TEST_CASE(test_no_resolve_symlink_on_symlink)
+{
+    scoped_test_env env;
+    const path file = env.create_file("file", 42);
+    const path sym = env.create_symlink(file, "sym");
+    const auto file_perms = status(file).permissions();
+
+    struct TestCase {
+        perms set_perms;
+        perms expected; // only expected on platform that support symlink perms.
+    } cases[] = {
+        {perms::owner_all, perms::owner_all},
+        {perms::group_all | perms::add_perms, perms::owner_all | perms::group_all},
+        {perms::owner_all | perms::remove_perms, perms::group_all},
+    };
+    for (auto const& TC : cases) {
+#if defined(__APPLE__) || defined(__FreeBSD__)
+        // On OS X symlink permissions are supported. We should get an empty
+        // error code and the expected permissions.
+        const auto expected_link_perms = TC.expected;
+        std::error_code expected_ec;
+#else
+        // On linux symlink permissions are not supported. The error code should
+        // be 'operation_not_supported' and the sylink permissions should be
+        // unchanged.
+        const auto expected_link_perms = symlink_status(sym).permissions();
+        std::error_code expected_ec = std::make_error_code(std::errc::operation_not_supported);
+#endif
+        std::error_code ec = std::make_error_code(std::errc::bad_address);
+        permissions(sym, TC.set_perms | perms::symlink_nofollow, ec);
+        TEST_CHECK(ec == expected_ec);
+        TEST_CHECK(status(file).permissions() == file_perms);
+        TEST_CHECK(symlink_status(sym).permissions() == expected_link_perms);
+    }
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.read_symlink/read_symlink.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.read_symlink/read_symlink.pass.cpp
new file mode 100644
index 000000000000..00581cbe8bcc
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.read_symlink/read_symlink.pass.cpp
@@ -0,0 +1,100 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// path read_symlink(const path& p);
+// path read_symlink(const path& p, error_code& ec);
+
+#include <experimental/filesystem>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+namespace fs = std::experimental::filesystem;
+
+TEST_SUITE(filesystem_read_symlink_test_suite)
+
+TEST_CASE(test_signatures)
+{
+    const path p; ((void)p);
+    std::error_code ec; ((void)ec);
+    ASSERT_SAME_TYPE(decltype(fs::read_symlink(p)), fs::path);
+    ASSERT_SAME_TYPE(decltype(fs::read_symlink(p, ec)), fs::path);
+
+    ASSERT_NOT_NOEXCEPT(fs::read_symlink(p));
+    // Not noexcept because of narrow contract
+    ASSERT_NOT_NOEXCEPT(fs::read_symlink(p, ec));
+}
+
+TEST_CASE(test_error_reporting)
+{
+    auto checkThrow = [](path const& f, const std::error_code& ec)
+    {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+        try {
+            fs::read_symlink(f);
+            return false;
+        } catch (filesystem_error const& err) {
+            return err.path1() == f
+                && err.path2() == ""
+                && err.code() == ec;
+        }
+#else
+        return true;
+#endif
+    };
+
+    scoped_test_env env;
+    const path cases[] = {
+        env.make_env_path("dne"),
+        env.create_file("file", 42),
+        env.create_dir("dir")
+    };
+    for (path const& p : cases) {
+        std::error_code ec;
+        const path ret = fs::read_symlink(p, ec);
+        TEST_REQUIRE(ec);
+        TEST_CHECK(ret == path{});
+        TEST_CHECK(checkThrow(p, ec));
+    }
+
+}
+
+TEST_CASE(basic_symlink_test)
+{
+    scoped_test_env env;
+    const path dne = env.make_env_path("dne");
+    const path file = env.create_file("file", 42);
+    const path dir = env.create_dir("dir");
+    const path link = env.create_symlink(dne, "link");
+    const path nested_link = env.make_env_path("nested_link");
+    create_symlink(link, nested_link);
+    struct TestCase {
+      path symlink;
+      path expected;
+    } testCases[] = {
+        {env.create_symlink(dne, "dne_link"), dne},
+        {env.create_symlink(file, "file_link"), file},
+        {env.create_symlink(dir, "dir_link"), dir},
+        {nested_link, link}
+    };
+    for (auto& TC : testCases) {
+        std::error_code ec = std::make_error_code(std::errc::address_in_use);
+        const path ret = read_symlink(TC.symlink, ec);
+        TEST_CHECK(!ec);
+        TEST_CHECK(ret == TC.expected);
+    }
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.remove/remove.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.remove/remove.pass.cpp
new file mode 100644
index 000000000000..edb0c4fc76c9
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.remove/remove.pass.cpp
@@ -0,0 +1,97 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// bool remove(const path& p);
+// bool remove(const path& p, error_code& ec) noexcept;
+
+#include <experimental/filesystem>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+namespace fs = std::experimental::filesystem;
+
+TEST_SUITE(filesystem_remove_test_suite)
+
+TEST_CASE(test_signatures)
+{
+    const path p; ((void)p);
+    std::error_code ec; ((void)ec);
+    ASSERT_SAME_TYPE(decltype(fs::remove(p)), bool);
+    ASSERT_SAME_TYPE(decltype(fs::remove(p, ec)), bool);
+
+    ASSERT_NOT_NOEXCEPT(fs::remove(p));
+    ASSERT_NOEXCEPT(fs::remove(p, ec));
+}
+
+TEST_CASE(test_error_reporting)
+{
+    auto checkThrow = [](path const& f, const std::error_code& ec)
+    {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+        try {
+            fs::remove(f);
+            return false;
+        } catch (filesystem_error const& err) {
+            return err.path1() == f
+                && err.path2() == ""
+                && err.code() == ec;
+        }
+#else
+        return true;
+#endif
+    };
+    scoped_test_env env;
+    const path non_empty_dir = env.create_dir("dir");
+    env.create_file(non_empty_dir / "file1", 42);
+    const path bad_perms_dir = env.create_dir("bad_dir");
+    const path file_in_bad_dir = env.create_file(bad_perms_dir / "file", 42);
+    permissions(bad_perms_dir, perms::none);
+    const path testCases[] = {
+        "",
+        env.make_env_path("dne"),
+        non_empty_dir,
+        file_in_bad_dir,
+    };
+    for (auto& p : testCases) {
+        std::error_code ec;
+        TEST_CHECK(!fs::remove(p, ec));
+        TEST_CHECK(ec);
+        TEST_CHECK(checkThrow(p, ec));
+    }
+}
+
+TEST_CASE(basic_remove_test)
+{
+    scoped_test_env env;
+    const path dne = env.make_env_path("dne");
+    const path link = env.create_symlink(dne, "link");
+    const path nested_link = env.make_env_path("nested_link");
+    create_symlink(link, nested_link);
+    const path testCases[] = {
+        env.create_file("file", 42),
+        env.create_dir("empty_dir"),
+        nested_link,
+        link
+    };
+    for (auto& p : testCases) {
+        std::error_code ec = std::make_error_code(std::errc::address_in_use);
+        TEST_CHECK(remove(p, ec));
+        TEST_CHECK(!ec);
+        TEST_CHECK(!exists(symlink_status(p)));
+    }
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.remove_all/remove_all.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.remove_all/remove_all.pass.cpp
new file mode 100644
index 000000000000..aecfce7885e9
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.remove_all/remove_all.pass.cpp
@@ -0,0 +1,141 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// uintmax_t remove_all(const path& p);
+// uintmax_t remove_all(const path& p, error_code& ec) noexcept;
+
+#include <experimental/filesystem>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+namespace fs = std::experimental::filesystem;
+
+TEST_SUITE(filesystem_remove_all_test_suite)
+
+TEST_CASE(test_signatures)
+{
+    const path p; ((void)p);
+    std::error_code ec; ((void)ec);
+    ASSERT_SAME_TYPE(decltype(fs::remove_all(p)), std::uintmax_t);
+    ASSERT_SAME_TYPE(decltype(fs::remove_all(p, ec)), std::uintmax_t);
+
+    ASSERT_NOT_NOEXCEPT(fs::remove_all(p));
+    ASSERT_NOEXCEPT(fs::remove_all(p, ec));
+}
+
+TEST_CASE(test_error_reporting)
+{
+    auto checkThrow = [](path const& f, const std::error_code& ec)
+    {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+        try {
+            fs::remove_all(f);
+            return false;
+        } catch (filesystem_error const& err) {
+            return err.path1() == f
+                && err.path2() == ""
+                && err.code() == ec;
+        }
+#else
+        return true;
+#endif
+    };
+    scoped_test_env env;
+    const path non_empty_dir = env.create_dir("dir");
+    env.create_file(non_empty_dir / "file1", 42);
+    const path bad_perms_dir = env.create_dir("bad_dir");
+    const path file_in_bad_dir = env.create_file(bad_perms_dir / "file", 42);
+    permissions(bad_perms_dir, perms::none);
+    const path bad_perms_file = env.create_file("file2", 42);
+    permissions(bad_perms_file, perms::none);
+
+    const path testCases[] = {
+        env.make_env_path("dne"),
+        file_in_bad_dir
+    };
+    const auto BadRet = static_cast<std::uintmax_t>(-1);
+    for (auto& p : testCases) {
+        std::error_code ec;
+        TEST_CHECK(fs::remove_all(p, ec) == BadRet);
+        TEST_CHECK(ec);
+        TEST_CHECK(checkThrow(p, ec));
+    }
+}
+
+TEST_CASE(basic_remove_all_test)
+{
+    scoped_test_env env;
+    const path dne = env.make_env_path("dne");
+    const path link = env.create_symlink(dne, "link");
+    const path nested_link = env.make_env_path("nested_link");
+    create_symlink(link, nested_link);
+    const path testCases[] = {
+        env.create_file("file", 42),
+        env.create_dir("empty_dir"),
+        nested_link,
+        link
+    };
+    for (auto& p : testCases) {
+        std::error_code ec = std::make_error_code(std::errc::address_in_use);
+        TEST_CHECK(remove(p, ec));
+        TEST_CHECK(!ec);
+        TEST_CHECK(!exists(symlink_status(p)));
+    }
+}
+
+TEST_CASE(symlink_to_dir)
+{
+    scoped_test_env env;
+    const path dir = env.create_dir("dir");
+    const path file = env.create_file(dir / "file", 42);
+    const path link = env.create_symlink(dir, "sym");
+
+    {
+        std::error_code ec = std::make_error_code(std::errc::address_in_use);
+        TEST_CHECK(remove_all(link, ec) == 1);
+        TEST_CHECK(!ec);
+        TEST_CHECK(!exists(symlink_status(link)));
+        TEST_CHECK(exists(dir));
+        TEST_CHECK(exists(file));
+    }
+}
+
+
+TEST_CASE(nested_dir)
+{
+    scoped_test_env env;
+    const path dir = env.create_dir("dir");
+    const path dir1 = env.create_dir(dir / "dir1");
+    const path out_of_dir_file = env.create_file("file1", 42);
+    const path all_files[] = {
+        dir, dir1,
+        env.create_file(dir / "file1", 42),
+        env.create_symlink(out_of_dir_file, dir / "sym1"),
+        env.create_file(dir1 / "file2", 42),
+        env.create_symlink(dir, dir1 / "sym2")
+    };
+    const std::size_t expected_count = sizeof(all_files) / sizeof(all_files[0]);
+
+    std::error_code ec = std::make_error_code(std::errc::address_in_use);
+    TEST_CHECK(remove_all(dir, ec) == expected_count);
+    TEST_CHECK(!ec);
+    for (auto const& p : all_files) {
+        TEST_CHECK(!exists(symlink_status(p)));
+    }
+    TEST_CHECK(exists(out_of_dir_file));
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.rename/rename.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.rename/rename.pass.cpp
new file mode 100644
index 000000000000..c2ae854c0bf6
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.rename/rename.pass.cpp
@@ -0,0 +1,125 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// void rename(const path& old_p, const path& new_p);
+// void rename(const path& old_p,  const path& new_p, error_code& ec) noexcept;
+
+#include <experimental/filesystem>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+namespace fs = std::experimental::filesystem;
+
+TEST_SUITE(filesystem_rename_test_suite)
+
+TEST_CASE(test_signatures)
+{
+    const path p; ((void)p);
+    std::error_code ec; ((void)ec);
+    ASSERT_SAME_TYPE(decltype(fs::rename(p, p)), void);
+    ASSERT_SAME_TYPE(decltype(fs::rename(p, p, ec)), void);
+
+    ASSERT_NOT_NOEXCEPT(fs::rename(p, p));
+    ASSERT_NOEXCEPT(fs::rename(p, p, ec));
+}
+
+TEST_CASE(test_error_reporting)
+{
+    auto checkThrow = [](path const& f, path const& t, const std::error_code& ec)
+    {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+        try {
+            fs::rename(f, t);
+            return false;
+        } catch (filesystem_error const& err) {
+            return err.path1() == f
+                && err.path2() == t
+                && err.code() == ec;
+        }
+#else
+        return true;
+#endif
+    };
+    scoped_test_env env;
+    const path dne = env.make_env_path("dne");
+    const path file = env.create_file("file1", 42);
+    const path dir = env.create_dir("dir1");
+    struct TestCase {
+      path from;
+      path to;
+    } cases[] = {
+        {dne, dne},
+        {file, dir},
+        {dir, file}
+    };
+    for (auto& TC : cases) {
+        auto from_before = status(TC.from);
+        auto to_before = status(TC.to);
+        std::error_code ec;
+        rename(TC.from, TC.to, ec);
+        TEST_REQUIRE(ec);
+        TEST_CHECK(from_before.type() == status(TC.from).type());
+        TEST_CHECK(to_before.type() == status(TC.to).type());
+        TEST_CHECK(checkThrow(TC.from, TC.to, ec));
+    }
+}
+
+TEST_CASE(basic_rename_test)
+{
+    scoped_test_env env;
+
+    const std::error_code set_ec = std::make_error_code(std::errc::address_in_use);
+    const path file = env.create_file("file1", 42);
+    { // same file
+        std::error_code ec = set_ec;
+        rename(file, file, ec);
+        TEST_CHECK(!ec);
+        TEST_CHECK(is_regular_file(file));
+        TEST_CHECK(file_size(file) == 42);
+    }
+    const path sym = env.create_symlink(file, "sym");
+    { // file -> symlink
+        std::error_code ec = set_ec;
+        rename(file, sym, ec);
+        TEST_CHECK(!ec);
+        TEST_CHECK(!exists(file));
+        TEST_CHECK(is_regular_file(symlink_status(sym)));
+        TEST_CHECK(file_size(sym) == 42);
+    }
+    const path file2 = env.create_file("file2", 42);
+    const path file3 = env.create_file("file3", 100);
+    { // file -> file
+        std::error_code ec = set_ec;
+        rename(file2, file3, ec);
+        TEST_CHECK(!ec);
+        TEST_CHECK(!exists(file2));
+        TEST_CHECK(is_regular_file(file3));
+        TEST_CHECK(file_size(file3) == 42);
+    }
+    const path dne = env.make_env_path("dne");
+    const path bad_sym = env.create_symlink(dne, "bad_sym");
+    const path bad_sym_dest = env.make_env_path("bad_sym2");
+    { // bad-symlink
+        std::error_code ec = set_ec;
+        rename(bad_sym, bad_sym_dest, ec);
+        TEST_CHECK(!ec);
+        TEST_CHECK(!exists(symlink_status(bad_sym)));
+        TEST_CHECK(is_symlink(bad_sym_dest));
+        TEST_CHECK(read_symlink(bad_sym_dest) == dne);
+    }
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.resize_file/resize_file.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.resize_file/resize_file.pass.cpp
new file mode 100644
index 000000000000..8a6aa09b14c7
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.resize_file/resize_file.pass.cpp
@@ -0,0 +1,109 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// void resize_file(const path& p, uintmax_t new_size);
+// void resize_file(const path& p, uintmax_t new_size, error_code& ec) noexcept;
+
+#include <experimental/filesystem>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+namespace fs = std::experimental::filesystem;
+
+TEST_SUITE(filesystem_resize_file_test_suite)
+
+TEST_CASE(test_signatures)
+{
+    const path p; ((void)p);
+    std::uintmax_t i; ((void)i);
+    std::error_code ec; ((void)ec);
+
+    ASSERT_SAME_TYPE(decltype(fs::resize_file(p, i)), void);
+    ASSERT_SAME_TYPE(decltype(fs::resize_file(p, i, ec)), void);
+
+    ASSERT_NOT_NOEXCEPT(fs::resize_file(p, i));
+    ASSERT_NOEXCEPT(fs::resize_file(p, i, ec));
+}
+
+TEST_CASE(test_error_reporting)
+{
+    auto checkThrow = [](path const& f, std::uintmax_t s, const std::error_code& ec)
+    {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+        try {
+            fs::resize_file(f, s);
+            return false;
+        } catch (filesystem_error const& err) {
+            return err.path1() == f
+                && err.path2() == ""
+                && err.code() == ec;
+        }
+#else
+        return true;
+#endif
+    };
+    scoped_test_env env;
+    const path dne = env.make_env_path("dne");
+    const path bad_sym = env.create_symlink(dne, "sym");
+    const path dir = env.create_dir("dir1");
+    const path cases[] = {
+        dne, bad_sym, dir
+    };
+    for (auto& p : cases) {
+        std::error_code ec;
+        resize_file(p, 42, ec);
+        TEST_REQUIRE(ec);
+        TEST_CHECK(checkThrow(p, 42, ec));
+    }
+}
+
+TEST_CASE(basic_resize_file_test)
+{
+    scoped_test_env env;
+    const path file1 = env.create_file("file1", 42);
+    const auto set_ec = std::make_error_code(std::errc::address_in_use);
+    { // grow file
+        const std::uintmax_t new_s = 100;
+        std::error_code ec = set_ec;
+        resize_file(file1, new_s, ec);
+        TEST_CHECK(!ec);
+        TEST_CHECK(file_size(file1) == new_s);
+    }
+    { // shrink file
+        const std::uintmax_t new_s = 1;
+        std::error_code ec = set_ec;
+        resize_file(file1, new_s, ec);
+        TEST_CHECK(!ec);
+        TEST_CHECK(file_size(file1) == new_s);
+    }
+    { // shrink file to zero
+        const std::uintmax_t new_s = 0;
+        std::error_code ec = set_ec;
+        resize_file(file1, new_s, ec);
+        TEST_CHECK(!ec);
+        TEST_CHECK(file_size(file1) == new_s);
+    }
+    const path sym = env.create_symlink(file1, "sym");
+    { // grow file via symlink
+        const std::uintmax_t new_s = 1024;
+        std::error_code ec = set_ec;
+        resize_file(sym, new_s, ec);
+        TEST_CHECK(!ec);
+        TEST_CHECK(file_size(file1) == new_s);
+    }
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.space/space.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.space/space.pass.cpp
new file mode 100644
index 000000000000..865191520be3
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.space/space.pass.cpp
@@ -0,0 +1,127 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// space_info space(const path& p);
+// space_info space(const path& p, error_code& ec) noexcept;
+
+#include <experimental/filesystem>
+#include <sys/statvfs.h>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+
+bool EqualDelta(std::uintmax_t x, std::uintmax_t y, std::uintmax_t delta) {
+    if (x >= y) {
+        return (x - y) <= delta;
+    } else {
+        return (y - x) <= delta;
+    }
+}
+
+TEST_SUITE(filesystem_space_test_suite)
+
+TEST_CASE(signature_test)
+{
+    const path p; ((void)p);
+    std::error_code ec; ((void)ec);
+    ASSERT_SAME_TYPE(decltype(space(p)), space_info);
+    ASSERT_SAME_TYPE(decltype(space(p, ec)), space_info);
+    ASSERT_NOT_NOEXCEPT(space(p));
+    ASSERT_NOEXCEPT(space(p, ec));
+}
+
+TEST_CASE(test_error_reporting)
+{
+    auto checkThrow = [](path const& f, const std::error_code& ec)
+    {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+        try {
+            space(f);
+            return false;
+        } catch (filesystem_error const& err) {
+            return err.path1() == f
+                && err.path2() == ""
+                && err.code() == ec;
+        }
+#else
+        return true;
+#endif
+    };
+    const path cases[] = {
+        "",
+        StaticEnv::DNE,
+        StaticEnv::BadSymlink
+    };
+    for (auto& p : cases) {
+        const auto expect = static_cast<std::uintmax_t>(-1);
+        std::error_code ec;
+        space_info info = space(p, ec);
+        TEST_CHECK(ec);
+        TEST_CHECK(info.capacity == expect);
+        TEST_CHECK(info.free == expect);
+        TEST_CHECK(info.available == expect);
+        TEST_CHECK(checkThrow(p, ec));
+    }
+}
+
+TEST_CASE(basic_space_test)
+{
+    // All the test cases should reside on the same filesystem and therefore
+    // should have the same expected result. Compute this expected result
+    // one and check that it looks semi-sane.
+    struct statvfs expect;
+    TEST_REQUIRE(::statvfs(StaticEnv::Dir.c_str(), &expect) != -1);
+    TEST_CHECK(expect.f_bavail > 0);
+    TEST_CHECK(expect.f_bfree > 0);
+    TEST_CHECK(expect.f_bsize > 0);
+    TEST_CHECK(expect.f_blocks > 0);
+    TEST_REQUIRE(expect.f_frsize > 0);
+    auto do_mult = [&](std::uintmax_t val) {
+        std::uintmax_t fsize = expect.f_frsize;
+        std::uintmax_t new_val = val * fsize;
+        TEST_CHECK(new_val / fsize == val); // Test for overflow
+        return new_val;
+    };
+    const std::uintmax_t bad_value = static_cast<std::uintmax_t>(-1);
+    const std::uintmax_t expect_capacity = do_mult(expect.f_blocks);
+    const std::uintmax_t expect_free = do_mult(expect.f_bfree);
+    const std::uintmax_t expect_avail = do_mult(expect.f_bavail);
+
+    // Other processes running on the operating system may have changed
+    // the amount of space available. Check that these are within tolerances.
+    // Currently 5% of capacity
+    const std::uintmax_t delta = expect_capacity / 20;
+    const path cases[] = {
+        StaticEnv::File,
+        StaticEnv::Dir,
+        StaticEnv::Dir2,
+        StaticEnv::SymlinkToFile,
+        StaticEnv::SymlinkToDir
+    };
+    for (auto& p : cases) {
+        std::error_code ec = GetTestEC();
+        space_info info = space(p, ec);
+        TEST_CHECK(!ec);
+        TEST_CHECK(info.capacity != bad_value);
+        TEST_CHECK(expect_capacity == info.capacity);
+        TEST_CHECK(info.free != bad_value);
+        TEST_CHECK(EqualDelta(expect_free, info.free, delta));
+        TEST_CHECK(info.available != bad_value);
+        TEST_CHECK(EqualDelta(expect_avail, info.available, delta));
+    }
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.status/status.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.status/status.pass.cpp
new file mode 100644
index 000000000000..2c76caf74c84
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.status/status.pass.cpp
@@ -0,0 +1,159 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// file_status status(const path& p);
+// file_status status(const path& p, error_code& ec) noexcept;
+
+#include <experimental/filesystem>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+
+TEST_SUITE(filesystem_status_test_suite)
+
+TEST_CASE(signature_test)
+{
+    const path p; ((void)p);
+    std::error_code ec; ((void)ec);
+    ASSERT_NOT_NOEXCEPT(status(p));
+    ASSERT_NOEXCEPT(status(p, ec));
+}
+
+TEST_CASE(test_status_not_found)
+{
+    const std::error_code expect_ec =
+        std::make_error_code(std::errc::no_such_file_or_directory);
+    const path cases[] {
+        StaticEnv::DNE,
+        StaticEnv::BadSymlink
+    };
+    for (auto& p : cases) {
+        std::error_code ec = std::make_error_code(std::errc::address_in_use);
+        // test non-throwing overload.
+        file_status st = status(p, ec);
+        TEST_CHECK(ec == expect_ec);
+        TEST_CHECK(st.type() == file_type::not_found);
+        TEST_CHECK(st.permissions() == perms::unknown);
+        // test throwing overload. It should not throw even though it reports
+        // that the file was not found.
+        TEST_CHECK_NO_THROW(st = status(p));
+        TEST_CHECK(st.type() == file_type::not_found);
+        TEST_CHECK(st.permissions() == perms::unknown);
+    }
+}
+
+TEST_CASE(test_status_cannot_resolve)
+{
+    scoped_test_env env;
+    const path dir = env.create_dir("dir");
+    const path file = env.create_file("dir/file", 42);
+    const path sym = env.create_symlink("dir/file", "sym");
+    permissions(dir, perms::none);
+
+    const std::error_code set_ec =
+        std::make_error_code(std::errc::address_in_use);
+    const std::error_code expect_ec =
+        std::make_error_code(std::errc::permission_denied);
+
+    const path cases[] = {
+        file, sym
+    };
+    for (auto& p : cases)
+    {
+        { // test non-throwing case
+            std::error_code ec = set_ec;
+            file_status st = status(p, ec);
+            TEST_CHECK(ec == expect_ec);
+            TEST_CHECK(st.type() == file_type::none);
+            TEST_CHECK(st.permissions() == perms::unknown);
+        }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+        { // test throwing case
+            try {
+                status(p);
+            } catch (filesystem_error const& err) {
+                TEST_CHECK(err.path1() == p);
+                TEST_CHECK(err.path2() == "");
+                TEST_CHECK(err.code() == expect_ec);
+            }
+        }
+#endif
+    }
+}
+
+TEST_CASE(status_file_types_test)
+{
+    scoped_test_env env;
+    struct TestCase {
+      path p;
+      file_type expect_type;
+    } cases[] = {
+        {StaticEnv::File, file_type::regular},
+        {StaticEnv::SymlinkToFile, file_type::regular},
+        {StaticEnv::Dir, file_type::directory},
+        {StaticEnv::SymlinkToDir, file_type::directory},
+        // Block files tested elsewhere
+        {StaticEnv::CharFile, file_type::character},
+#if !defined(__APPLE__) && !defined(__FreeBSD__) // No support for domain sockets
+        {env.create_socket("socket"), file_type::socket},
+#endif
+        {env.create_fifo("fifo"), file_type::fifo}
+    };
+    for (const auto& TC : cases) {
+        // test non-throwing case
+        std::error_code ec = std::make_error_code(std::errc::address_in_use);
+        file_status st = status(TC.p, ec);
+        TEST_CHECK(!ec);
+        TEST_CHECK(st.type() == TC.expect_type);
+        TEST_CHECK(st.permissions() != perms::unknown);
+        // test throwing case
+        TEST_REQUIRE_NO_THROW(st = status(TC.p));
+        TEST_CHECK(st.type() == TC.expect_type);
+        TEST_CHECK(st.permissions() != perms::unknown);
+    }
+}
+
+TEST_CASE(test_block_file)
+{
+    const path possible_paths[] = {
+        "/dev/drive0", // Apple
+        "/dev/sda",
+        "/dev/loop0"
+    };
+    path p;
+    for (const path& possible_p : possible_paths) {
+        std::error_code ec;
+        if (exists(possible_p, ec)) {
+            p = possible_p;
+            break;
+        }
+    }
+    if (p == path{}) {
+        TEST_UNSUPPORTED();
+    }
+    // test non-throwing case
+    std::error_code ec = std::make_error_code(std::errc::address_in_use);
+    file_status st = status(p, ec);
+    TEST_CHECK(!ec);
+    TEST_CHECK(st.type() == file_type::block);
+    TEST_CHECK(st.permissions() != perms::unknown);
+    // test throwing case
+    TEST_REQUIRE_NO_THROW(st = status(p));
+    TEST_CHECK(st.type() == file_type::block);
+    TEST_CHECK(st.permissions() != perms::unknown);
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.status_known/status_known.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.status_known/status_known.pass.cpp
new file mode 100644
index 000000000000..169c5be9d9a8
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.status_known/status_known.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
+
+// <experimental/filesystem>
+
+// bool status_known(file_status s) noexcept;
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+
+TEST_SUITE(status_known_test_suite)
+
+TEST_CASE(signature_test)
+{
+    file_status s; ((void)s);
+    ASSERT_SAME_TYPE(decltype(status_known(s)), bool);
+    ASSERT_NOEXCEPT(status_known(s));
+}
+
+TEST_CASE(status_known_test)
+{
+    struct TestCase {
+        file_type type;
+        bool expect;
+    };
+    const TestCase testCases[] = {
+        {file_type::none, false},
+        {file_type::not_found, true},
+        {file_type::regular, true},
+        {file_type::directory, true},
+        {file_type::symlink, true},
+        {file_type::block, true},
+        {file_type::character, true},
+        {file_type::fifo, true},
+        {file_type::socket, true},
+        {file_type::unknown, true}
+    };
+    for (auto& TC : testCases) {
+        file_status s(TC.type);
+        TEST_CHECK(status_known(s) == TC.expect);
+    }
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.symlink_status/symlink_status.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.symlink_status/symlink_status.pass.cpp
new file mode 100644
index 000000000000..647504f6e1a4
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.symlink_status/symlink_status.pass.cpp
@@ -0,0 +1,192 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// file_status symlink_status(const path& p);
+// file_status symlink_status(const path& p, error_code& ec) noexcept;
+
+#include <experimental/filesystem>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+
+TEST_SUITE(filesystem_symlink_status_test_suite)
+
+TEST_CASE(signature_test)
+{
+    const path p; ((void)p);
+    std::error_code ec; ((void)ec);
+    ASSERT_NOT_NOEXCEPT(symlink_status(p));
+    ASSERT_NOEXCEPT(symlink_status(p, ec));
+}
+
+TEST_CASE(test_symlink_status_not_found)
+{
+    const std::error_code expect_ec =
+        std::make_error_code(std::errc::no_such_file_or_directory);
+    const path cases[] {
+        StaticEnv::DNE
+    };
+    for (auto& p : cases) {
+        std::error_code ec = std::make_error_code(std::errc::address_in_use);
+        // test non-throwing overload.
+        file_status st = symlink_status(p, ec);
+        TEST_CHECK(ec == expect_ec);
+        TEST_CHECK(st.type() == file_type::not_found);
+        TEST_CHECK(st.permissions() == perms::unknown);
+        // test throwing overload. It should not throw even though it reports
+        // that the file was not found.
+        TEST_CHECK_NO_THROW(st = status(p));
+        TEST_CHECK(st.type() == file_type::not_found);
+        TEST_CHECK(st.permissions() == perms::unknown);
+    }
+}
+
+TEST_CASE(test_symlink_status_cannot_resolve)
+{
+    scoped_test_env env;
+    const path dir = env.create_dir("dir");
+    const path file_in_dir = env.create_file("dir/file", 42);
+    const path sym_in_dir = env.create_symlink("dir/file", "dir/bad_sym");
+    const path sym_points_in_dir = env.create_symlink("dir/file", "sym");
+    permissions(dir, perms::none);
+
+    const std::error_code set_ec =
+        std::make_error_code(std::errc::address_in_use);
+    const std::error_code expect_ec =
+        std::make_error_code(std::errc::permission_denied);
+
+    const path fail_cases[] = {
+        file_in_dir, sym_in_dir
+    };
+    for (auto& p : fail_cases)
+    {
+        { // test non-throwing case
+            std::error_code ec = set_ec;
+            file_status st = symlink_status(p, ec);
+            TEST_CHECK(ec == expect_ec);
+            TEST_CHECK(st.type() == file_type::none);
+            TEST_CHECK(st.permissions() == perms::unknown);
+        }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+        { // test throwing case
+            try {
+                symlink_status(p);
+            } catch (filesystem_error const& err) {
+                TEST_CHECK(err.path1() == p);
+                TEST_CHECK(err.path2() == "");
+                TEST_CHECK(err.code() == expect_ec);
+            }
+        }
+#endif
+    }
+    // Test that a symlink that points into a directory without read perms
+    // can be stat-ed using symlink_status
+    {
+        std::error_code ec = set_ec;
+        file_status st = symlink_status(sym_points_in_dir, ec);
+        TEST_CHECK(!ec);
+        TEST_CHECK(st.type() == file_type::symlink);
+        TEST_CHECK(st.permissions() != perms::unknown);
+        // test non-throwing version
+        TEST_REQUIRE_NO_THROW(st = symlink_status(sym_points_in_dir));
+        TEST_CHECK(st.type() == file_type::symlink);
+        TEST_CHECK(st.permissions() != perms::unknown);
+    }
+}
+
+
+TEST_CASE(symlink_status_file_types_test)
+{
+    scoped_test_env env;
+    struct TestCase {
+      path p;
+      file_type expect_type;
+    } cases[] = {
+        {StaticEnv::BadSymlink, file_type::symlink},
+        {StaticEnv::File, file_type::regular},
+        {StaticEnv::SymlinkToFile, file_type::symlink},
+        {StaticEnv::Dir, file_type::directory},
+        {StaticEnv::SymlinkToDir, file_type::symlink},
+        // Block files tested elsewhere
+        {StaticEnv::CharFile, file_type::character},
+#if !defined(__APPLE__) && !defined(__FreeBSD__) // No support for domain sockets
+        {env.create_socket("socket"), file_type::socket},
+#endif
+        {env.create_fifo("fifo"), file_type::fifo}
+    };
+    for (const auto& TC : cases) {
+        // test non-throwing case
+        std::error_code ec = std::make_error_code(std::errc::address_in_use);
+        file_status st = symlink_status(TC.p, ec);
+        TEST_CHECK(!ec);
+        TEST_CHECK(st.type() == TC.expect_type);
+        TEST_CHECK(st.permissions() != perms::unknown);
+        // test throwing case
+        TEST_REQUIRE_NO_THROW(st = symlink_status(TC.p));
+        TEST_CHECK(st.type() == TC.expect_type);
+        TEST_CHECK(st.permissions() != perms::unknown);
+    }
+}
+
+TEST_CASE(test_block_file)
+{
+    const path possible_paths[] = {
+        "/dev/drive0", // Apple
+        "/dev/sda",    // Linux
+        "/dev/loop0"   // Linux
+        // No FreeBSD files known
+    };
+    path p;
+    for (const path& possible_p : possible_paths) {
+        std::error_code ec;
+        if (exists(possible_p, ec)) {
+            p = possible_p;
+            break;
+        }
+    }
+    if (p == path{}) {
+        TEST_UNSUPPORTED();
+    }
+    scoped_test_env env;
+    { // test block file
+        // test non-throwing case
+        std::error_code ec = std::make_error_code(std::errc::address_in_use);
+        file_status st = symlink_status(p, ec);
+        TEST_CHECK(!ec);
+        TEST_CHECK(st.type() == file_type::block);
+        TEST_CHECK(st.permissions() != perms::unknown);
+        // test throwing case
+        TEST_REQUIRE_NO_THROW(st = symlink_status(p));
+        TEST_CHECK(st.type() == file_type::block);
+        TEST_CHECK(st.permissions() != perms::unknown);
+    }
+    const path sym = env.make_env_path("sym");
+    create_symlink(p, sym);
+    { // test symlink to block file
+        // test non-throwing case
+        std::error_code ec = std::make_error_code(std::errc::address_in_use);
+        file_status st = symlink_status(sym, ec);
+        TEST_CHECK(!ec);
+        TEST_CHECK(st.type() == file_type::symlink);
+        TEST_CHECK(st.permissions() != perms::unknown);
+        // test throwing case
+        TEST_REQUIRE_NO_THROW(st = symlink_status(sym));
+        TEST_CHECK(st.type() == file_type::symlink);
+        TEST_CHECK(st.permissions() != perms::unknown);
+    }
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.system_complete/system_complete.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.system_complete/system_complete.pass.cpp
new file mode 100644
index 000000000000..634184e24e6d
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.system_complete/system_complete.pass.cpp
@@ -0,0 +1,58 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// path system_complete(const path& p);
+// path system_complete(const path& p, error_code& ec);
+
+// Note: For POSIX based operating systems, 'system_complete(p)' has the
+// same semantics as 'absolute(p, current_path())'.
+
+#include <experimental/filesystem>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+
+TEST_SUITE(filesystem_system_complete_test_suite)
+
+TEST_CASE(signature_test)
+{
+    const path p; ((void)p);
+    std::error_code ec; ((void)ec);
+    ASSERT_NOT_NOEXCEPT(system_complete(p));
+    ASSERT_NOT_NOEXCEPT(system_complete(p, ec));
+}
+
+
+TEST_CASE(basic_system_complete_tests)
+{
+    const path testCases[] = {
+        "//net/foo", //  has_root_name() &&  has_root_directory()
+        "/foo",      // !has_root_name() &&  has_root_directory()
+        "//net",     //  has_root_name() && !has_root_directory()
+        "bar/baz"    // !has_root_name() && !has_root_directory()
+    };
+    const path base = current_path();
+    for (auto& p : testCases) {
+        const path ret = system_complete(p);
+        const path expect = absolute(p, base);
+        TEST_CHECK(ret.is_absolute());
+        TEST_CHECK(ret == expect);
+    }
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.temp_dir_path/temp_directory_path.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.temp_dir_path/temp_directory_path.pass.cpp
new file mode 100644
index 000000000000..215c35a33f30
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.temp_dir_path/temp_directory_path.pass.cpp
@@ -0,0 +1,110 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// path temp_directory_path();
+// path temp_directory_path(error_code& ec);
+
+#include <experimental/filesystem>
+#include <memory>
+#include <cstdlib>
+#include <cstring>
+#include <cassert>
+
+#include "test_macros.h"
+#include "rapid-cxx-test.hpp"
+#include "filesystem_test_helper.hpp"
+
+using namespace std::experimental::filesystem;
+
+void PutEnv(std::string var, std::string value) {
+    assert(::setenv(var.c_str(), value.c_str(), /* overwrite */ 1) == 0);
+}
+
+void UnsetEnv(std::string var) {
+    assert(::unsetenv(var.c_str()) == 0);
+}
+
+TEST_SUITE(filesystem_temp_directory_path_test_suite)
+
+TEST_CASE(signature_test)
+{
+    std::error_code ec; ((void)ec);
+    ASSERT_NOT_NOEXCEPT(temp_directory_path());
+    ASSERT_NOT_NOEXCEPT(temp_directory_path(ec));
+}
+
+TEST_CASE(basic_tests)
+{
+    scoped_test_env env;
+    const path dne = env.make_env_path("dne");
+    const path file = env.create_file("file", 42);
+    const path dir_perms = env.create_dir("bad_perms_dir");
+    const path nested_dir = env.create_dir("bad_perms_dir/nested");
+    permissions(dir_perms, perms::none);
+    const std::error_code set_ec = std::make_error_code(std::errc::address_in_use);
+    const std::error_code expect_ec = std::make_error_code(std::errc::not_a_directory);
+    struct TestCase {
+      std::string name;
+      path p;
+    } cases[] = {
+        {"TMPDIR", env.create_dir("dir1")},
+        {"TMP", env.create_dir("dir2")},
+        {"TEMP", env.create_dir("dir3")},
+        {"TEMPDIR", env.create_dir("dir4")}
+    };
+    for (auto& TC : cases) {
+        PutEnv(TC.name, TC.p);
+    }
+    for (auto& TC : cases) {
+        std::error_code ec = set_ec;
+        path ret = temp_directory_path(ec);
+        TEST_CHECK(!ec);
+        TEST_CHECK(ret == TC.p);
+        TEST_CHECK(is_directory(ret));
+
+        // Set the env variable to a path that does not exist and check
+        // that it fails.
+        PutEnv(TC.name, dne);
+        ec = set_ec;
+        ret = temp_directory_path(ec);
+        TEST_CHECK(ec == expect_ec);
+        TEST_CHECK(ret == "");
+
+        // Set the env variable to point to a file and check that it fails.
+        PutEnv(TC.name, file);
+        ec = set_ec;
+        ret = temp_directory_path(ec);
+        TEST_CHECK(ec == expect_ec);
+        TEST_CHECK(ret == "");
+
+        // Set the env variable to point to a dir we can't access
+        PutEnv(TC.name, nested_dir);
+        ec = set_ec;
+        ret = temp_directory_path(ec);
+        TEST_CHECK(ec == std::make_error_code(std::errc::permission_denied));
+        TEST_CHECK(ret == "");
+
+        // Finally erase this env variable
+        UnsetEnv(TC.name);
+    }
+    // No env variables are defined
+    {
+        std::error_code ec = set_ec;
+        path ret = temp_directory_path(ec);
+        TEST_CHECK(!ec);
+        TEST_CHECK(ret == "/tmp");
+        TEST_CHECK(is_directory(ret));
+    }
+}
+
+TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.req.macros/feature_macro.pass.cpp b/test/std/experimental/filesystem/fs.req.macros/feature_macro.pass.cpp
new file mode 100644
index 000000000000..d57dff4a7b78
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.req.macros/feature_macro.pass.cpp
@@ -0,0 +1,24 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// #define __cpp_lib_experimental_filesystem 201406L
+
+#include <experimental/filesystem>
+
+#ifndef __cpp_lib_experimental_filesystem
+#error Filesystem feature test macro is not defined  (__cpp_lib_experimental_filesystem)
+#elif __cpp_lib_experimental_filesystem != 201406L
+#error Filesystem feature test macro has an incorrect value (__cpp_lib_experimental_filesystem)
+#endif
+
+int main() { }
diff --git a/test/std/experimental/filesystem/fs.req.namespace/namespace.pass.cpp b/test/std/experimental/filesystem/fs.req.namespace/namespace.pass.cpp
new file mode 100644
index 000000000000..77ae7b0989be
--- /dev/null
+++ b/test/std/experimental/filesystem/fs.req.namespace/namespace.pass.cpp
@@ -0,0 +1,24 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/filesystem>
+
+// namespace std::experimental::filesystem::v1
+
+#include <experimental/filesystem>
+#include <type_traits>
+
+int main() {
+  static_assert(std::is_same<
+          std::experimental::filesystem::path,
+          std::experimental::filesystem::v1::path
+      >::value, "");
+}
diff --git a/test/std/experimental/filesystem/lit.local.cfg b/test/std/experimental/filesystem/lit.local.cfg
new file mode 100644
index 000000000000..3d9360431f48
--- /dev/null
+++ b/test/std/experimental/filesystem/lit.local.cfg
@@ -0,0 +1,3 @@
+# Disable all of the filesystem tests if the correct feature is not available.
+if 'c++filesystem' not in config.available_features:
+  config.unsupported = True
diff --git a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/default.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/default.pass.cpp
index 7647b536aa95..ae1b64222a29 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/default.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/default.pass.cpp
@@ -19,11 +19,11 @@
 // public:
 //   boyer_moore_searcher(RandomAccessIterator1 pat_first, RandomAccessIterator1 pat_last,
 //                        Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate());
-// 
+//
 //   template<class RandomAccessIterator2>
-//   RandomAccessIterator2
+//   pair<RandomAccessIterator2, RandomAccessIterator2>
 //   operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const;
-// 
+//
 // private:
 //   RandomAccessIterator1 pat_first_; // exposition only
 //   RandomAccessIterator1 pat_last_;  // exposition only
diff --git a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pass.cpp
index 1323044c8704..bc44f1f6cbbf 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pass.cpp
@@ -19,11 +19,11 @@
 // public:
 //   boyer_moore_searcher(RandomAccessIterator1 pat_first, RandomAccessIterator1 pat_last,
 //                        Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate());
-// 
+//
 //   template<class RandomAccessIterator2>
-//   RandomAccessIterator2
+//   pair<RandomAccessIterator2, RandomAccessIterator2>
 //   operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const;
-// 
+//
 // private:
 //   RandomAccessIterator1 pat_first_; // exposition only
 //   RandomAccessIterator1 pat_last_;  // exposition only
@@ -44,7 +44,7 @@ template <typename T> struct MyHash {
 
 template <typename Iter1, typename Iter2>
 void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result, unsigned max_count) {
-    std::experimental::boyer_moore_searcher<Iter2, 
+    std::experimental::boyer_moore_searcher<Iter2,
                  MyHash<typename std::remove_cv<typename std::iterator_traits<Iter2>::value_type>::type>>
           s{b2, e2};
     assert(result == std::experimental::search(b1, e1, s));
diff --git a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pred.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pred.pass.cpp
index 8fd5b8c9f784..743ab92156be 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pred.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pred.pass.cpp
@@ -19,11 +19,11 @@
 // public:
 //   boyer_moore_searcher(RandomAccessIterator1 pat_first, RandomAccessIterator1 pat_last,
 //                        Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate());
-// 
+//
 //   template<class RandomAccessIterator2>
-//   RandomAccessIterator2
+//   pair<RandomAccessIterator2, RandomAccessIterator2>
 //   operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const;
-// 
+//
 // private:
 //   RandomAccessIterator1 pat_first_; // exposition only
 //   RandomAccessIterator1 pat_last_;  // exposition only
@@ -54,7 +54,7 @@ unsigned count_equal::count = 0;
 
 template <typename Iter1, typename Iter2>
 void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result, unsigned max_count) {
-    std::experimental::boyer_moore_searcher<Iter2, 
+    std::experimental::boyer_moore_searcher<Iter2,
                  MyHash<typename std::remove_cv<typename std::iterator_traits<Iter2>::value_type>::type>,
                  count_equal>
           s{b2, e2};
diff --git a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/pred.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/pred.pass.cpp
index d0655c82febb..b27cabd76ab3 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/pred.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/pred.pass.cpp
@@ -19,11 +19,11 @@
 // public:
 //   boyer_moore_searcher(RandomAccessIterator1 pat_first, RandomAccessIterator1 pat_last,
 //                        Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate());
-// 
+//
 //   template<class RandomAccessIterator2>
-//   RandomAccessIterator2
+//   pair<RandomAccessIterator2, RandomAccessIterator2>
 //   operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const;
-// 
+//
 // private:
 //   RandomAccessIterator1 pat_first_; // exposition only
 //   RandomAccessIterator1 pat_last_;  // exposition only
@@ -50,7 +50,7 @@ unsigned count_equal::count = 0;
 
 template <typename Iter1, typename Iter2>
 void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result, unsigned max_count) {
-    std::experimental::boyer_moore_searcher<Iter2, 
+    std::experimental::boyer_moore_searcher<Iter2,
            typename std::hash<typename std::remove_cv<typename std::iterator_traits<Iter2>::value_type>::type>, count_equal> s{b2, e2};
     count_equal::count = 0;
     assert(result == std::experimental::search(b1, e1, s));
diff --git a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/default.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/default.pass.cpp
index af3bbbafb24e..cbf9b41d590f 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/default.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/default.pass.cpp
@@ -19,11 +19,11 @@
 // public:
 //   boyer_moore_horspool_searcher(RandomAccessIterator1 pat_first, RandomAccessIterator1 pat_last,
 //                                 Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate());
-// 
+//
 //   template<class RandomAccessIterator2>
-//   RandomAccessIterator2
+//   pair<RandomAccessIterator2, RandomAccessIterator2>
 //   operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const;
-// 
+//
 // private:
 //   RandomAccessIterator1 pat_first_; // exposition only
 //   RandomAccessIterator1 pat_last_;  // exposition only
diff --git a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pass.cpp
index ff289f0edeb0..28a3f6d912f8 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pass.cpp
@@ -19,11 +19,11 @@
 // public:
 //   boyer_moore_horspool_searcher(RandomAccessIterator1 pat_first, RandomAccessIterator1 pat_last,
 //                                 Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate());
-// 
+//
 //   template<class RandomAccessIterator2>
-//   RandomAccessIterator2
+//   pair<RandomAccessIterator2, RandomAccessIterator2>
 //   operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const;
-// 
+//
 // private:
 //   RandomAccessIterator1 pat_first_; // exposition only
 //   RandomAccessIterator1 pat_last_;  // exposition only
@@ -43,7 +43,7 @@ template <typename T> struct MyHash {
 
 template <typename Iter1, typename Iter2>
 void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result, unsigned max_count) {
-    std::experimental::boyer_moore_horspool_searcher<Iter2, 
+    std::experimental::boyer_moore_horspool_searcher<Iter2,
                  MyHash<typename std::remove_cv<typename std::iterator_traits<Iter2>::value_type>::type>>
           s{b2, e2};
     assert(result == std::experimental::search(b1, e1, s));
diff --git a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pred.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pred.pass.cpp
index 1150210a978a..3a6647dbc7f5 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pred.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pred.pass.cpp
@@ -19,11 +19,11 @@
 // public:
 //   boyer_moore_horspool_searcher(RandomAccessIterator1 pat_first, RandomAccessIterator1 pat_last,
 //                                 Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate());
-// 
+//
 //   template<class RandomAccessIterator2>
-//   RandomAccessIterator2
+//   pair<RandomAccessIterator2, RandomAccessIterator2>
 //   operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const;
-// 
+//
 // private:
 //   RandomAccessIterator1 pat_first_; // exposition only
 //   RandomAccessIterator1 pat_last_;  // exposition only
@@ -53,7 +53,7 @@ unsigned count_equal::count = 0;
 
 template <typename Iter1, typename Iter2>
 void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result, unsigned max_count) {
-    std::experimental::boyer_moore_horspool_searcher<Iter2, 
+    std::experimental::boyer_moore_horspool_searcher<Iter2,
                  MyHash<typename std::remove_cv<typename std::iterator_traits<Iter2>::value_type>::type>,
                  count_equal>
           s{b2, e2};
diff --git a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/pred.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/pred.pass.cpp
index 55426874abe5..8c78b9de0b35 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/pred.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/pred.pass.cpp
@@ -19,11 +19,11 @@
 // public:
 //   boyer_moore_horspool_searcher(RandomAccessIterator1 pat_first, RandomAccessIterator1 pat_last,
 //                                 Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate());
-// 
+//
 //   template<class RandomAccessIterator2>
-//   RandomAccessIterator2
+//   pair<RandomAccessIterator2, RandomAccessIterator2>
 //   operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const;
-// 
+//
 // private:
 //   RandomAccessIterator1 pat_first_; // exposition only
 //   RandomAccessIterator1 pat_last_;  // exposition only
@@ -49,7 +49,7 @@ unsigned count_equal::count = 0;
 
 template <typename Iter1, typename Iter2>
 void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result, unsigned max_count) {
-    std::experimental::boyer_moore_horspool_searcher<Iter2, 
+    std::experimental::boyer_moore_horspool_searcher<Iter2,
            typename std::hash<typename std::remove_cv<typename std::iterator_traits<Iter2>::value_type>::type>, count_equal> s{b2, e2};
     count_equal::count = 0;
     assert(result == std::experimental::search(b1, e1, s));
diff --git a/test/std/experimental/func/func.searchers/func.searchers.default/default.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.default/default.pass.cpp
index 446dcbde42be..4eaf3a870390 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.default/default.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.default/default.pass.cpp
@@ -15,15 +15,16 @@
 // template<class _ForwardIterator, class _BinaryPredicate = equal_to<>>
 // class default_searcher {
 // public:
-//     default_searcher(_ForwardIterator __f, _ForwardIterator __l, 
+//     default_searcher(_ForwardIterator __f, _ForwardIterator __l,
 //                             _BinaryPredicate __p = _BinaryPredicate())
 //         : __first_(__f), __last_(__l), __pred_(__p) {}
-// 
+//
 //     template <typename _ForwardIterator2>
-//     _ForwardIterator2 operator () (_ForwardIterator2 __f, _ForwardIterator2 __l) const {
+//     pair<_ForwardIterator2, _ForwardIterator2>
+//     operator () (_ForwardIterator2 __f, _ForwardIterator2 __l) const {
 //         return std::search(__f, __l, __first_, __last_, __pred_);
 //         }
-// 
+//
 // private:
 //     _ForwardIterator __first_;
 //     _ForwardIterator __last_;
diff --git a/test/std/experimental/func/func.searchers/func.searchers.default/default.pred.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.default/default.pred.pass.cpp
index b65c500c3192..a2f690d7b7bf 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.default/default.pred.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.default/default.pred.pass.cpp
@@ -15,15 +15,16 @@
 // template<class _ForwardIterator, class _BinaryPredicate = equal_to<>>
 // class default_searcher {
 // public:
-//     default_searcher(_ForwardIterator __f, _ForwardIterator __l, 
+//     default_searcher(_ForwardIterator __f, _ForwardIterator __l,
 //                             _BinaryPredicate __p = _BinaryPredicate())
 //         : __first_(__f), __last_(__l), __pred_(__p) {}
-// 
+//
 //     template <typename _ForwardIterator2>
-//     _ForwardIterator2 operator () (_ForwardIterator2 __f, _ForwardIterator2 __l) const {
+//     pair<_ForwardIterator2, _ForwardIterator2>
+//     operator () (_ForwardIterator2 __f, _ForwardIterator2 __l) const {
 //         return std::search(__f, __l, __first_, __last_, __pred_);
 //         }
-// 
+//
 // private:
 //     _ForwardIterator __first_;
 //     _ForwardIterator __last_;
diff --git a/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pass.cpp
index 9528002d5f2d..7798a6e73f5e 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pass.cpp
@@ -25,7 +25,7 @@
 
 template <typename Iter1, typename Iter2>
 void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result) {
-    assert(result == std::experimental::search(b1, e1, 
+    assert(result == std::experimental::search(b1, e1,
         std::experimental::make_default_searcher(b2, e2)));
 }
 
diff --git a/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pred.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pred.pass.cpp
index 277020213149..21f50a397e2a 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pred.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pred.pass.cpp
@@ -36,7 +36,7 @@ unsigned count_equal::count = 0;
 template <typename Iter1, typename Iter2>
 void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result, unsigned max_count) {
     count_equal::count = 0;
-    assert(result == std::experimental::search(b1, e1, 
+    assert(result == std::experimental::search(b1, e1,
         std::experimental::make_default_searcher(b2, e2)));
     assert(count_equal::count <= max_count);
 }
diff --git a/test/std/experimental/iterator/nothing_to_do.pass.cpp b/test/std/experimental/iterator/nothing_to_do.pass.cpp
new file mode 100644
index 000000000000..892d6895a326
--- /dev/null
+++ b/test/std/experimental/iterator/nothing_to_do.pass.cpp
@@ -0,0 +1,12 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+#include <experimental/iterator>
+
+int main () {}
diff --git a/test/std/experimental/iterator/ostream.joiner/ostream.joiner.cons/ostream_joiner.cons.pass.cpp b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.cons/ostream_joiner.cons.pass.cpp
new file mode 100644
index 000000000000..5c84d210e53e
--- /dev/null
+++ b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.cons/ostream_joiner.cons.pass.cpp
@@ -0,0 +1,58 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <experimental/iterator>
+//
+// template <class _Delim, class _CharT = char, class _Traits = char_traits<_CharT>>
+//   class ostream_joiner;
+//
+//     ostream_joiner(ostream_type& __os, _Delim&& __d);
+//     ostream_joiner(ostream_type& __os, const _Delim& __d);
+
+#include <experimental/iterator>
+#include <iostream>
+#include <string>
+
+#include "test_macros.h"
+
+namespace exp = std::experimental;
+
+int main () {
+	const char eight = '8';
+	const std::string nine = "9";
+	const std::wstring ten = L"10";
+	const int eleven = 11;
+
+//	Narrow streams w/rvalues
+	{ exp::ostream_joiner<char>         oj(std::cout, '8'); }
+	{ exp::ostream_joiner<std::string>  oj(std::cout, std::string("9")); }
+	{ exp::ostream_joiner<std::wstring> oj(std::cout, std::wstring(L"10")); }
+	{ exp::ostream_joiner<int>          oj(std::cout, 11); }
+
+//	Narrow streams w/lvalues
+	{ exp::ostream_joiner<char>         oj(std::cout, eight); }
+	{ exp::ostream_joiner<std::string>  oj(std::cout, nine); }
+	{ exp::ostream_joiner<std::wstring> oj(std::cout, ten); }
+	{ exp::ostream_joiner<int>          oj(std::cout, eleven); }
+
+//	Wide streams w/rvalues
+	{ exp::ostream_joiner<char, wchar_t>         oj(std::wcout, '8'); }
+	{ exp::ostream_joiner<std::string, wchar_t>  oj(std::wcout, std::string("9")); }
+	{ exp::ostream_joiner<std::wstring, wchar_t> oj(std::wcout, std::wstring(L"10")); }
+	{ exp::ostream_joiner<int, wchar_t>          oj(std::wcout, 11); }
+
+//	Wide streams w/lvalues
+	{ exp::ostream_joiner<char, wchar_t>         oj(std::wcout, eight); }
+	{ exp::ostream_joiner<std::string, wchar_t>  oj(std::wcout, nine); }
+	{ exp::ostream_joiner<std::wstring, wchar_t> oj(std::wcout, ten); }
+	{ exp::ostream_joiner<int, wchar_t>          oj(std::wcout, eleven); }
+
+	}
diff --git a/test/std/experimental/iterator/ostream.joiner/ostream.joiner.creation/make_ostream_joiner.pass.cpp b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.creation/make_ostream_joiner.pass.cpp
new file mode 100644
index 000000000000..a8c1b286f1de
--- /dev/null
+++ b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.creation/make_ostream_joiner.pass.cpp
@@ -0,0 +1,53 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <experimental/iterator>
+//
+// template <class _Delim, class _CharT = char, class _Traits = char_traits<_CharT>>
+//   class ostream_joiner;
+//
+//   template <class _CharT, class _Traits, class _Delim>
+//   ostream_joiner<typename decay<_Delim>::type, _CharT, _Traits>
+//   make_ostream_joiner(basic_ostream<_CharT, _Traits>& __os, _Delim && __d);
+//
+
+#include <experimental/iterator>
+#include <iostream>
+#include <sstream>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+
+namespace exp = std::experimental;
+
+template <class Delim, class Iter, class CharT = char, class Traits = std::char_traits<CharT>>
+void test (Delim &&d, Iter first, Iter last, const CharT *expected ) {
+    std::basic_stringstream<CharT, Traits> sstream;
+    auto joiner = exp::make_ostream_joiner(sstream, d);
+    typedef exp::ostream_joiner<typename std::decay<Delim>::type, CharT, Traits> Joiner;
+    static_assert((std::is_same<decltype(joiner), Joiner>::value), "" );
+    while (first != last)
+        joiner = *first++;
+    assert(sstream.str() == expected);
+    }
+
+int main () {
+    const char chars[] = "0123456789";
+    const int  ints [] = { 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 };
+
+//  There are more of these tests in another file.
+//  This is just to make sure that the ostream_joiner is created correctly
+    test('X', chars, chars+10, "0X1X2X3X4X5X6X7X8X9");
+    test('x', ints,  ints+10,  "10x11x12x13x14x15x16x17x18x19");
+    test("Z", chars, chars+10, "0Z1Z2Z3Z4Z5Z6Z7Z8Z9");
+    test("z", ints,  ints+10,  "10z11z12z13z14z15z16z17z18z19");
+    }
diff --git a/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.assign.pass.cpp b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.assign.pass.cpp
new file mode 100644
index 000000000000..b2c294fd034b
--- /dev/null
+++ b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.assign.pass.cpp
@@ -0,0 +1,120 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <experimental/iterator>
+//
+// template <class _Delim, class _CharT = char, class _Traits = char_traits<_CharT>>
+//   class ostream_joiner;
+//
+//   template<typename T>
+//   ostream_joiner & operator=(const T&)
+//
+
+#include <experimental/iterator>
+#include <iostream>
+#include <sstream>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+
+struct mutating_delimiter {
+	mutating_delimiter(char c = ' ') : c_(c) {}
+	char get () const { return c_++; }
+	mutable char c_;
+	};
+
+template<class _CharT, class _Traits>
+std::basic_ostream<_CharT, _Traits>&
+operator<<(std::basic_ostream<_CharT, _Traits>& os, const mutating_delimiter &d)
+{ return os << d.get(); }
+
+
+struct mutating_delimiter2 { // same as above, w/o the const and the mutable
+	mutating_delimiter2(char c = ' ') : c_(c) {}
+	char get () { return c_++; }
+	char c_;
+	};
+
+template<class _CharT, class _Traits>
+std::basic_ostream<_CharT, _Traits>&
+operator<<(std::basic_ostream<_CharT, _Traits>& os, mutating_delimiter2 &d)
+{ return os << d.get(); }
+
+
+namespace exp = std::experimental;
+
+template <class Delim, class Iter, class CharT = char, class Traits = std::char_traits<CharT>>
+void test (Delim &&d, Iter first, Iter last, const CharT *expected ) {
+	typedef exp::ostream_joiner<typename std::decay<Delim>::type, CharT, Traits> Joiner;
+
+	static_assert((std::is_copy_constructible<Joiner>::value == std::is_copy_constructible<typename std::decay<Delim>::type>::value), "" );
+	static_assert((std::is_move_constructible<Joiner>::value == std::is_move_constructible<typename std::decay<Delim>::type>::value), "" );
+	static_assert((std::is_copy_assignable<Joiner>   ::value == std::is_copy_assignable<typename std::decay<Delim>::type>   ::value), "" );
+	static_assert((std::is_move_assignable<Joiner>   ::value == std::is_move_assignable<typename std::decay<Delim>::type>   ::value), "" );
+
+	std::basic_stringstream<CharT, Traits> sstream;
+	Joiner joiner(sstream, d);
+	while (first != last)
+		*joiner++ = *first++;
+	assert(sstream.str() == expected);
+	}
+
+int main () {
+{
+	const char chars[] = "0123456789";
+	const int  ints [] = { 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 };
+
+	test('X', chars, chars+10, "0X1X2X3X4X5X6X7X8X9");
+	test('x',  ints,  ints+10, "10x11x12x13x14x15x16x17x18x19");
+	test('X', input_iterator<const char*>(chars),         input_iterator<const char*>(chars+10),         "0X1X2X3X4X5X6X7X8X9");
+	test('x', input_iterator<const int*>(ints),           input_iterator<const int*>(ints+10),           "10x11x12x13x14x15x16x17x18x19");
+	test('X', forward_iterator<const char*>(chars),       forward_iterator<const char*>(chars+10),       "0X1X2X3X4X5X6X7X8X9");
+	test('x', forward_iterator<const int*>(ints),         forward_iterator<const int*>(ints+10),         "10x11x12x13x14x15x16x17x18x19");
+	test('X', random_access_iterator<const char*>(chars), random_access_iterator<const char*>(chars+10), "0X1X2X3X4X5X6X7X8X9");
+	test('x', random_access_iterator<const int*>(ints),   random_access_iterator<const int*>(ints+10),   "10x11x12x13x14x15x16x17x18x19");
+
+	test("Z", chars, chars+10, "0Z1Z2Z3Z4Z5Z6Z7Z8Z9");
+	test("z", ints,  ints+10,  "10z11z12z13z14z15z16z17z18z19");
+
+	test<char, const char *, wchar_t> ('X', chars, chars+10, L"0X1X2X3X4X5X6X7X8X9");
+	test<char, const int *,  wchar_t> ('x',  ints,  ints+10, L"10x11x12x13x14x15x16x17x18x19");
+// 	test<char, const char *, char16_t>('X', chars, chars+10, u"0X1X2X3X4X5X6X7X8X9");
+// 	test<char, const int *,  char16_t>('x',  ints,  ints+10, u"10x11x12x13x14x15x16x17x18x19");
+// 	test<char, const char *, char32_t>('X', chars, chars+10, U"0X1X2X3X4X5X6X7X8X9");
+// 	test<char, const int *,  char32_t>('x',  ints,  ints+10, U"10x11x12x13x14x15x16x17x18x19");
+
+	test(mutating_delimiter(),  chars, chars+10, "0 1!2\"3#4$5%6&7'8(9");
+	test(mutating_delimiter2(), chars, chars+10, "0 1!2\"3#4$5%6&7'8(9");
+	}
+
+	{
+	const wchar_t chars[] = L"0123456789";
+	const int  ints [] = { 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 };
+	test(L'X', chars, chars+10, L"0X1X2X3X4X5X6X7X8X9");
+	test(L'x',  ints,  ints+10, L"10x11x12x13x14x15x16x17x18x19");
+	test(L'X', input_iterator<const wchar_t*>(chars),         input_iterator<const wchar_t*>(chars+10),         L"0X1X2X3X4X5X6X7X8X9");
+	test(L'x', input_iterator<const int*>(ints),              input_iterator<const int*>(ints+10),              L"10x11x12x13x14x15x16x17x18x19");
+	test(L'X', forward_iterator<const wchar_t*>(chars),       forward_iterator<const wchar_t*>(chars+10),       L"0X1X2X3X4X5X6X7X8X9");
+	test(L'x', forward_iterator<const int*>(ints),            forward_iterator<const int*>(ints+10),            L"10x11x12x13x14x15x16x17x18x19");
+	test(L'X', random_access_iterator<const wchar_t*>(chars), random_access_iterator<const wchar_t*>(chars+10), L"0X1X2X3X4X5X6X7X8X9");
+	test(L'x', random_access_iterator<const int*>(ints),      random_access_iterator<const int*>(ints+10),      L"10x11x12x13x14x15x16x17x18x19");
+
+	test(L"Z", chars, chars+10, L"0Z1Z2Z3Z4Z5Z6Z7Z8Z9");
+	test(L"z", ints,  ints+10,  L"10z11z12z13z14z15z16z17z18z19");
+
+	test<char, const wchar_t *, wchar_t> ('X', chars, chars+10, L"0X1X2X3X4X5X6X7X8X9");
+	test<char, const int *,  wchar_t>    ('x',  ints,  ints+10, L"10x11x12x13x14x15x16x17x18x19");
+
+	test(mutating_delimiter(), chars, chars+10, L"0 1!2\"3#4$5%6&7'8(9");
+	}
+
+}
diff --git a/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.postincrement.pass.cpp b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.postincrement.pass.cpp
new file mode 100644
index 000000000000..e3872c3e030b
--- /dev/null
+++ b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.postincrement.pass.cpp
@@ -0,0 +1,46 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <experimental/iterator>
+//
+// template <class _Delim, class _CharT = char, class _Traits = char_traits<_CharT>>
+//   class ostream_joiner;
+//
+//   ostream_joiner & operator++(int) noexcept
+//     returns *this;
+
+#include <experimental/iterator>
+#include <iostream>
+#include <cassert>
+
+#include "test_macros.h"
+
+namespace exp = std::experimental;
+
+template <class Delim, class CharT, class Traits>
+void test ( exp::ostream_joiner<Delim, CharT, Traits> &oj ) {
+    static_assert((noexcept(oj++)), "" );
+    exp::ostream_joiner<Delim, CharT, Traits> &ret = oj++;
+    assert( &ret == &oj );
+    }
+
+int main () {
+
+    { exp::ostream_joiner<char>         oj(std::cout, '8');                 test(oj); }
+    { exp::ostream_joiner<std::string>  oj(std::cout, std::string("9"));    test(oj); }
+    { exp::ostream_joiner<std::wstring> oj(std::cout, std::wstring(L"10")); test(oj); }
+    { exp::ostream_joiner<int>          oj(std::cout, 11);                  test(oj); }
+
+    { exp::ostream_joiner<char, wchar_t>         oj(std::wcout, '8');                 test(oj); }
+    { exp::ostream_joiner<std::string, wchar_t>  oj(std::wcout, std::string("9"));    test(oj); }
+    { exp::ostream_joiner<std::wstring, wchar_t> oj(std::wcout, std::wstring(L"10")); test(oj); }
+    { exp::ostream_joiner<int, wchar_t>          oj(std::wcout, 11);                  test(oj); }
+    }
diff --git a/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.pretincrement.pass.cpp b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.pretincrement.pass.cpp
new file mode 100644
index 000000000000..87b493e6393a
--- /dev/null
+++ b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.pretincrement.pass.cpp
@@ -0,0 +1,46 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <experimental/iterator>
+//
+// template <class _Delim, class _CharT = char, class _Traits = char_traits<_CharT>>
+//   class ostream_joiner;
+//
+//   ostream_joiner & operator++() noexcept
+//     returns *this;
+
+#include <experimental/iterator>
+#include <iostream>
+#include <cassert>
+
+#include "test_macros.h"
+
+namespace exp = std::experimental;
+
+template <class Delim, class CharT, class Traits>
+void test ( exp::ostream_joiner<Delim, CharT, Traits> &oj ) {
+    static_assert((noexcept(++oj)), "" );
+    exp::ostream_joiner<Delim, CharT, Traits> &ret = ++oj;
+    assert( &ret == &oj );
+    }
+
+int main () {
+
+    { exp::ostream_joiner<char>         oj(std::cout, '8');                 test(oj); }
+    { exp::ostream_joiner<std::string>  oj(std::cout, std::string("9"));    test(oj); }
+    { exp::ostream_joiner<std::wstring> oj(std::cout, std::wstring(L"10")); test(oj); }
+    { exp::ostream_joiner<int>          oj(std::cout, 11);                  test(oj); }
+
+    { exp::ostream_joiner<char, wchar_t>         oj(std::wcout, '8');                 test(oj); }
+    { exp::ostream_joiner<std::string, wchar_t>  oj(std::wcout, std::string("9"));    test(oj); }
+    { exp::ostream_joiner<std::wstring, wchar_t> oj(std::wcout, std::wstring(L"10")); test(oj); }
+    { exp::ostream_joiner<int, wchar_t>          oj(std::wcout, 11);                  test(oj); }
+    }
diff --git a/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.star.pass.cpp b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.star.pass.cpp
new file mode 100644
index 000000000000..794346d75e7f
--- /dev/null
+++ b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.star.pass.cpp
@@ -0,0 +1,46 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <experimental/iterator>
+//
+// template <class _Delim, class _CharT = char, class _Traits = char_traits<_CharT>>
+//   class ostream_joiner;
+//
+//   ostream_joiner & operator*() noexcept
+//     returns *this;
+
+#include <experimental/iterator>
+#include <iostream>
+#include <cassert>
+
+#include "test_macros.h"
+
+namespace exp = std::experimental;
+
+template <class Delim, class CharT, class Traits>
+void test ( exp::ostream_joiner<Delim, CharT, Traits> &oj ) {
+    static_assert((noexcept(*oj)), "" );
+    exp::ostream_joiner<Delim, CharT, Traits> &ret = *oj;
+    assert( &ret == &oj );
+    }
+
+int main () {
+
+    { exp::ostream_joiner<char>         oj(std::cout, '8');                 test(oj); }
+    { exp::ostream_joiner<std::string>  oj(std::cout, std::string("9"));    test(oj); }
+    { exp::ostream_joiner<std::wstring> oj(std::cout, std::wstring(L"10")); test(oj); }
+    { exp::ostream_joiner<int>          oj(std::cout, 11);                  test(oj); }
+
+    { exp::ostream_joiner<char, wchar_t>         oj(std::wcout, '8');                 test(oj); }
+    { exp::ostream_joiner<std::string, wchar_t>  oj(std::wcout, std::string("9"));    test(oj); }
+    { exp::ostream_joiner<std::wstring, wchar_t> oj(std::wcout, std::wstring(L"10")); test(oj); }
+    { exp::ostream_joiner<int, wchar_t>          oj(std::wcout, 11);                  test(oj); }
+    }
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/assign.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/assign.pass.cpp
new file mode 100644
index 000000000000..c4309d9097aa
--- /dev/null
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/assign.pass.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// polymorphic_allocator operator=(polymorphic_allocator const &) = delete
+
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <cassert>
+
+namespace ex = std::experimental::pmr;
+
+int main()
+{
+    typedef ex::polymorphic_allocator<void> T;
+    static_assert(!std::is_copy_assignable<T>::value, "");
+    static_assert(!std::is_move_assignable<T>::value, "");
+}
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/copy.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/copy.pass.cpp
new file mode 100644
index 000000000000..ba3710d4de1b
--- /dev/null
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/copy.pass.cpp
@@ -0,0 +1,48 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// polymorphic_allocator<T>::polymorphic_allocator(polymorphic_allocator const &);
+
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <cassert>
+
+namespace ex = std::experimental::pmr;
+
+int main()
+{
+    typedef ex::polymorphic_allocator<void> A1;
+    {
+        static_assert(
+            std::is_copy_constructible<A1>::value, ""
+          );
+        static_assert(
+            std::is_move_constructible<A1>::value, ""
+          );
+    }
+    // copy
+    {
+        A1 const a((ex::memory_resource*)42);
+        A1 const a2(a);
+        assert(a.resource() == a2.resource());
+    }
+    // move
+    {
+        A1 a((ex::memory_resource*)42);
+        A1 a2(std::move(a));
+        assert(a.resource() == a2.resource());
+        assert(a2.resource() == (ex::memory_resource*)42);
+    }
+}
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/default.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/default.pass.cpp
new file mode 100644
index 000000000000..b696d0c13fb3
--- /dev/null
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/default.pass.cpp
@@ -0,0 +1,49 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++experimental
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// polymorphic_allocator<T>::polymorphic_allocator() noexcept
+
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <cassert>
+
+#include "test_memory_resource.hpp"
+
+namespace ex = std::experimental::pmr;
+
+int main()
+{
+    {
+        static_assert(
+            std::is_nothrow_default_constructible<ex::polymorphic_allocator<void>>::value
+          , "Must me nothrow default constructible"
+          );
+    }
+    {
+        // test that the allocator gets its resource from get_default_resource
+        TestResource R1(42);
+        ex::set_default_resource(&R1);
+
+        typedef ex::polymorphic_allocator<void> A;
+        A const a;
+        assert(a.resource() == &R1);
+
+        ex::set_default_resource(nullptr);
+        A const a2;
+        assert(a.resource() == &R1);
+        assert(a2.resource() == ex::new_delete_resource());
+    }
+}
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/memory_resource_convert.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/memory_resource_convert.pass.cpp
new file mode 100644
index 000000000000..19d9646ad616
--- /dev/null
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/memory_resource_convert.pass.cpp
@@ -0,0 +1,45 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// polymorphic_allocator<T>::polymorphic_allocator(memory_resource *)
+
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <cassert>
+
+#include "test_memory_resource.hpp"
+
+namespace ex = std::experimental::pmr;
+
+int main()
+{
+    {
+        typedef ex::polymorphic_allocator<void> A;
+        static_assert(
+            std::is_convertible<decltype(nullptr), A>::value
+          , "Must be convertible"
+          );
+        static_assert(
+            std::is_convertible<ex::memory_resource *, A>::value
+          , "Must be convertible"
+          );
+    }
+    {
+        typedef ex::polymorphic_allocator<void> A;
+        TestResource R;
+        A const a(&R);
+        assert(a.resource() == &R);
+    }
+}
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/other_alloc.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/other_alloc.pass.cpp
new file mode 100644
index 000000000000..aadfbcc322fc
--- /dev/null
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/other_alloc.pass.cpp
@@ -0,0 +1,57 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// template <class U>
+// polymorphic_allocator<T>::polymorphic_allocator(polymorphic_allocator<U> const &);
+
+
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <cassert>
+
+namespace ex = std::experimental::pmr;
+
+int main()
+{
+    typedef ex::polymorphic_allocator<void> A1;
+    typedef ex::polymorphic_allocator<char> A2;
+    { // Test that the conversion is implicit and noexcept.
+        static_assert(
+            std::is_convertible<A1 const &, A2>::value, ""
+          );
+        static_assert(
+            std::is_convertible<A2 const &, A1>::value, ""
+          );
+        static_assert(
+            std::is_nothrow_constructible<A1, A2 const &>::value, ""
+          );
+        static_assert(
+            std::is_nothrow_constructible<A2, A1 const &>::value, ""
+          );
+    }
+    // copy other type
+    {
+        A1 const a((ex::memory_resource*)42);
+        A2 const a2(a);
+        assert(a.resource() == a2.resource());
+        assert(a2.resource() == (ex::memory_resource*)42);
+    }
+    {
+        A1 a((ex::memory_resource*)42);
+        A2 const a2(std::move(a));
+        assert(a.resource() == a2.resource());
+        assert(a2.resource() == (ex::memory_resource*)42);
+    }
+}
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/equal.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/equal.pass.cpp
new file mode 100644
index 000000000000..d4aea1cf5f21
--- /dev/null
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/equal.pass.cpp
@@ -0,0 +1,134 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++experimental
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/memory_resource>
+
+// template <class T> class polymorphic_allocator;
+
+// template <class T, class U>
+// bool operator==(
+//      polymorphic_allocator<T> const &
+//    , polymorphic_allocator<U> const &) noexcept
+
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <cassert>
+
+#include "test_memory_resource.hpp"
+
+namespace ex = std::experimental::pmr;
+
+int main()
+{
+    typedef ex::polymorphic_allocator<void> A1;
+    typedef ex::polymorphic_allocator<int> A2;
+    // check return types
+    {
+        A1 const a1;
+        A2 const a2;
+        static_assert(std::is_same<decltype(a1 == a2), bool>::value, "");
+        static_assert(noexcept(a1 == a2), "");
+    }
+    // equal same type (different resource)
+    {
+        TestResource d1(1);
+        TestResource d2(1);
+        A1 const a1(&d1);
+        A1 const a2(&d2);
+
+        assert(a1 == a2);
+        assert(d1.checkIsEqualCalledEq(1));
+        assert(d2.checkIsEqualCalledEq(0));
+
+        d1.reset();
+
+        assert(a2 == a1);
+        assert(d1.checkIsEqualCalledEq(0));
+        assert(d2.checkIsEqualCalledEq(1));
+    }
+    // equal same type (same resource)
+    {
+        TestResource d1;
+        A1 const a1(&d1);
+        A1 const a2(&d1);
+
+        assert(a1 == a2);
+        assert(d1.checkIsEqualCalledEq(0));
+
+        assert(a2 == a1);
+        assert(d1.checkIsEqualCalledEq(0));
+    }
+    // equal different type (different resource)
+    {
+        TestResource d1(42);
+        TestResource d2(42);
+        A1 const a1(&d1);
+        A2 const a2(&d2);
+
+        assert(a1 == a2);
+        assert(d1.checkIsEqualCalledEq(1));
+        assert(d2.checkIsEqualCalledEq(0));
+
+        assert(a2 == a1);
+        assert(d1.checkIsEqualCalledEq(1));
+        assert(d2.checkIsEqualCalledEq(1));
+
+    }
+    // equal different type (same resource)
+    {
+        TestResource d1(42);
+        A1 const a1(&d1);
+        A2 const a2(&d1);
+
+        assert(a1 == a2);
+        assert(d1.checkIsEqualCalledEq(0));
+
+        assert(a2 == a1);
+        assert(d1.checkIsEqualCalledEq(0));
+
+    }
+    // not equal same type
+    {
+        TestResource d1(1);
+        TestResource d2(2);
+        A1 const a1(&d1);
+        A1 const a2(&d2);
+
+        assert(!(a1 == a2));
+        assert(d1.checkIsEqualCalledEq(1));
+        assert(d2.checkIsEqualCalledEq(0));
+
+        d1.reset();
+
+        assert(!(a2 == a1));
+        assert(d1.checkIsEqualCalledEq(0));
+        assert(d2.checkIsEqualCalledEq(1));
+
+    }
+    // not equal different types
+    {
+        TestResource  d1;
+        TestResource1 d2;
+        A1 const a1(&d1);
+        A2 const a2(&d2);
+
+        assert(!(a1 == a2));
+        assert(d1.checkIsEqualCalledEq(1));
+        assert(d2.checkIsEqualCalledEq(0));
+
+        d1.reset();
+
+        assert(!(a2 == a1));
+        assert(d1.checkIsEqualCalledEq(0));
+        assert(d2.checkIsEqualCalledEq(1));
+    }
+}
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/not_equal.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/not_equal.pass.cpp
new file mode 100644
index 000000000000..7b9b1d3857b7
--- /dev/null
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/not_equal.pass.cpp
@@ -0,0 +1,105 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++experimental
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/memory_resource>
+
+// template <class T> class polymorphic_allocator;
+
+// template <class T>
+// bool operator!=(
+//      polymorphic_allocator<T> const &
+//    , polymorphic_allocator<T> const &) noexcept
+
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <cassert>
+
+#include "test_memory_resource.hpp"
+
+namespace ex = std::experimental::pmr;
+
+int main()
+{
+    typedef ex::polymorphic_allocator<void> A1;
+    typedef ex::polymorphic_allocator<int> A2;
+    // check return types
+    {
+        A1 const a1;
+        A2 const a2;
+        static_assert(std::is_same<decltype(a1 != a2), bool>::value, "");
+        static_assert(noexcept(a1 != a2), "");
+    }
+    // not equal same type (different resource)
+    {
+        TestResource d1(1);
+        TestResource d2(2);
+        A1 const a1(&d1);
+        A1 const a2(&d2);
+
+        assert(a1 != a2);
+        assert(d1.checkIsEqualCalledEq(1));
+        assert(d2.checkIsEqualCalledEq(0));
+
+        d1.reset();
+
+        assert(a2 != a1);
+        assert(d1.checkIsEqualCalledEq(0));
+        assert(d2.checkIsEqualCalledEq(1));
+    }
+    // equal same type (same resource)
+    {
+        TestResource d1;
+        A1 const a1(&d1);
+        A1 const a2(&d1);
+
+        assert(!(a1 != a2));
+        assert(d1.checkIsEqualCalledEq(0));
+
+        assert(!(a2 != a1));
+        assert(d1.checkIsEqualCalledEq(0));
+    }
+    // equal same type
+    {
+        TestResource d1(1);
+        TestResource d2(1);
+        A1 const a1(&d1);
+        A1 const a2(&d2);
+
+        assert(!(a1 != a2));
+        assert(d1.checkIsEqualCalledEq(1));
+        assert(d2.checkIsEqualCalledEq(0));
+
+        d1.reset();
+
+        assert(!(a2 != a1));
+        assert(d1.checkIsEqualCalledEq(0));
+        assert(d2.checkIsEqualCalledEq(1));
+
+    }
+    // not equal different types
+    {
+        TestResource  d1;
+        TestResource1 d2;
+        A1 const a1(&d1);
+        A2 const a2(&d2);
+
+        assert(a1 != a2);
+        assert(d1.checkIsEqualCalledEq(1));
+        assert(d2.checkIsEqualCalledEq(0));
+
+        d1.reset();
+
+        assert(a2 != a1);
+        assert(d1.checkIsEqualCalledEq(0));
+        assert(d2.checkIsEqualCalledEq(1));
+    }
+}
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/allocate.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/allocate.pass.cpp
new file mode 100644
index 000000000000..a7efad1156dc
--- /dev/null
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/allocate.pass.cpp
@@ -0,0 +1,112 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++experimental
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// T* polymorphic_allocator<T>::allocate(size_t n)
+
+#include <experimental/memory_resource>
+#include <limits>
+#include <memory>
+#include <exception>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_memory_resource.hpp"
+
+namespace ex = std::experimental::pmr;
+
+template <size_t S, size_t Align>
+void testForSizeAndAlign() {
+    using T = typename std::aligned_storage<S, Align>::type;
+    TestResource R;
+    ex::polymorphic_allocator<T> a(&R);
+
+    for (int N = 1; N <= 5; ++N) {
+        auto ret = a.allocate(N);
+        assert(R.checkAlloc(ret, N * sizeof(T), alignof(T)));
+
+        a.deallocate(ret, N);
+        R.reset();
+    }
+}
+
+#ifndef TEST_HAS_NO_EXCEPTIONS
+template <size_t S>
+void testAllocForSizeThrows() {
+    using T = typename std::aligned_storage<S>::type;
+    using Alloc = ex::polymorphic_allocator<T>;
+    using Traits = std::allocator_traits<Alloc>;
+    NullResource R;
+    Alloc a(&R);
+
+    // Test that allocating exactly the max size does not throw.
+    size_t maxSize = Traits::max_size(a);
+    try {
+        a.allocate(maxSize);
+    } catch (...) {
+        assert(false);
+    }
+
+    size_t sizeTypeMax = std::numeric_limits<std::size_t>::max();
+    if (maxSize != sizeTypeMax)
+    {
+        // Test that allocating size_t(~0) throws bad alloc.
+        try {
+            a.allocate(sizeTypeMax);
+            assert(false);
+        } catch (std::exception const&) {
+        }
+
+        // Test that allocating even one more than the max size does throw.
+        size_t overSize = maxSize + 1;
+        try {
+            a.allocate(overSize);
+            assert(false);
+        } catch (std::exception const&) {
+        }
+    }
+}
+#endif // TEST_HAS_NO_EXCEPTIONS
+
+int main()
+{
+    {
+        ex::polymorphic_allocator<int> a;
+        static_assert(std::is_same<decltype(a.allocate(0)), int*>::value, "");
+        static_assert(!noexcept(a.allocate(0)), "");
+    }
+    {
+        constexpr std::size_t MA = alignof(std::max_align_t);
+        testForSizeAndAlign<1, 1>();
+        testForSizeAndAlign<1, 2>();
+        testForSizeAndAlign<1, MA>();
+        testForSizeAndAlign<2, 2>();
+        testForSizeAndAlign<73, alignof(void*)>();
+        testForSizeAndAlign<73, MA>();
+        testForSizeAndAlign<13, MA>();
+    }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    {
+        testAllocForSizeThrows<1>();
+        testAllocForSizeThrows<2>();
+        testAllocForSizeThrows<4>();
+        testAllocForSizeThrows<8>();
+        testAllocForSizeThrows<16>();
+        testAllocForSizeThrows<73>();
+        testAllocForSizeThrows<13>();
+    }
+#endif
+}
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair.pass.cpp
new file mode 100644
index 000000000000..2b43594756b7
--- /dev/null
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair.pass.cpp
@@ -0,0 +1,53 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++experimental
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// template <class U1, class U2>
+// void polymorphic_allocator<T>::construct(pair<U1, U2>*)
+
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <utility>
+#include <tuple>
+#include <cassert>
+#include <cstdlib>
+#include "uses_alloc_types.hpp"
+
+namespace ex = std::experimental::pmr;
+
+int constructed = 0;
+
+struct default_constructible
+{
+    default_constructible() : x(42)  { ++constructed; }
+    int x{0};
+};
+
+int main()
+{
+    // pair<default_constructible, default_constructible> as T()
+    {
+        typedef default_constructible T;
+        typedef std::pair<T, T> P;
+        typedef ex::polymorphic_allocator<void> A;
+        P * ptr = (P*)std::malloc(sizeof(P));
+        A a;
+        a.construct(ptr);
+        assert(constructed == 2);
+        assert(ptr->first.x == 42);
+        assert(ptr->second.x == 42);
+        std::free(ptr);
+    }
+}
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_const_lvalue_pair.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_const_lvalue_pair.pass.cpp
new file mode 100644
index 000000000000..50a71eeca82b
--- /dev/null
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_const_lvalue_pair.pass.cpp
@@ -0,0 +1,112 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++experimental
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// template <class P1, class P2, class U1, class U2>
+// void polymorphic_allocator<T>::construct(pair<P1, P2>*, pair<U1, U2> const&)
+
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <utility>
+#include <tuple>
+#include <cassert>
+#include <cstdlib>
+#include "uses_alloc_types.hpp"
+
+namespace ex = std::experimental::pmr;
+
+
+template <class UA1, class UA2, class TT, class UU>
+bool doTest(UsesAllocatorType TExpect, UsesAllocatorType UExpect,
+            std::pair<TT, UU> const& p)
+{
+    using P = std::pair<UA1, UA2>;
+    TestResource R;
+    ex::memory_resource * M = &R;
+    ex::polymorphic_allocator<P> A(M);
+    P * ptr = (P*)std::malloc(sizeof(P));
+    P * ptr2 =  (P*)std::malloc(sizeof(P));
+
+    // UNDER TEST //
+    A.construct(ptr, p);
+
+    A.construct(ptr2, std::piecewise_construct,
+                std::forward_as_tuple(p.first),
+                std::forward_as_tuple(p.second));
+    // ------- //
+
+    bool tres = checkConstruct<decltype((p.first))>(ptr->first, TExpect, M) &&
+                checkConstructionEquiv(ptr->first, ptr2->first);
+
+    bool ures = checkConstruct<decltype((p.second))>(ptr->second, UExpect, M) &&
+                checkConstructionEquiv(ptr->second, ptr2->second);
+
+    A.destroy(ptr);
+    std::free(ptr);
+    A.destroy(ptr2);
+    std::free(ptr2);
+    return tres && ures;
+
+}
+
+template <class Alloc, class TT, class UU>
+void test_pmr_uses_allocator(std::pair<TT, UU> const& p)
+{
+    {
+        using T = NotUsesAllocator<Alloc, 1>;
+        using U = NotUsesAllocator<Alloc, 1>;
+        assert((doTest<T, U>(UA_None, UA_None, p)));
+    }
+    {
+        using T = UsesAllocatorV1<Alloc, 1>;
+        using U = UsesAllocatorV2<Alloc, 1>;
+        assert((doTest<T, U>(UA_AllocArg, UA_AllocLast, p)));
+    }
+    {
+        using T = UsesAllocatorV2<Alloc, 1>;
+        using U = UsesAllocatorV3<Alloc, 1>;
+        assert((doTest<T, U>(UA_AllocLast, UA_AllocArg, p)));
+    }
+    {
+        using T = UsesAllocatorV3<Alloc, 1>;
+        using U = NotUsesAllocator<Alloc, 1>;
+        assert((doTest<T, U>(UA_AllocArg, UA_None, p)));
+    }
+}
+template <class Tp>
+struct Print;
+
+int main()
+{
+    using ERT = std::experimental::erased_type;
+    using PMR = ex::memory_resource*;
+    using PMA = ex::polymorphic_allocator<char>;
+    {
+        int x = 42;
+        int y = 42;
+        const std::pair<int, int&> p(x, y);
+        test_pmr_uses_allocator<ERT>(p);
+        test_pmr_uses_allocator<PMR>(p);
+        test_pmr_uses_allocator<PMA>(p);
+    }
+    {
+        int x = 42;
+        int y = 42;
+        const std::pair<int&, int&&> p(x, std::move(y));
+        test_pmr_uses_allocator<ERT>(p);
+        test_pmr_uses_allocator<PMR>(p);
+        test_pmr_uses_allocator<PMA>(p);
+    }
+}
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_rvalue.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_rvalue.pass.cpp
new file mode 100644
index 000000000000..b6adb558b1e4
--- /dev/null
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_rvalue.pass.cpp
@@ -0,0 +1,109 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++experimental
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// template <class P1, class P2, class U1, class U2>
+// void polymorphic_allocator<T>::construct(pair<P1, P2>*, pair<U1, U2> &&)
+
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <utility>
+#include <tuple>
+#include <cassert>
+#include <cstdlib>
+#include "uses_alloc_types.hpp"
+
+namespace ex = std::experimental::pmr;
+
+
+
+template <class UA1, class UA2, class TT, class UU>
+bool doTest(UsesAllocatorType TExpect, UsesAllocatorType UExpect,
+            std::pair<TT, UU>&& p)
+{
+    using P = std::pair<UA1, UA2>;
+    TestResource R;
+    ex::memory_resource * M = &R;
+    ex::polymorphic_allocator<P> A(M);
+    P * ptr  = A.allocate(2);
+    P * ptr2 = ptr + 1;
+
+    // UNDER TEST //
+    A.construct(ptr, std::move(p));
+
+    A.construct(ptr2, std::piecewise_construct,
+                std::forward_as_tuple(std::forward<TT>(p.first)),
+                std::forward_as_tuple(std::forward<UU>(p.second)));
+    // ------- //
+
+    bool tres = checkConstruct<TT&&>(ptr->first, TExpect, M) &&
+                checkConstructionEquiv(ptr->first, ptr2->first);
+
+    bool ures = checkConstruct<UU&&>(ptr->second, UExpect, M) &&
+                checkConstructionEquiv(ptr->second, ptr2->second);
+
+    A.destroy(ptr);
+    A.destroy(ptr2);
+    A.deallocate(ptr, 2);
+    return tres && ures;
+}
+
+template <class Alloc, class TT, class UU>
+void test_pmr_uses_allocator(std::pair<TT, UU>&& p)
+{
+    {
+        using T = NotUsesAllocator<Alloc, 1>;
+        using U = NotUsesAllocator<Alloc, 1>;
+        assert((doTest<T, U>(UA_None, UA_None, std::move(p))));
+    }
+    {
+        using T = UsesAllocatorV1<Alloc, 1>;
+        using U = UsesAllocatorV2<Alloc, 1>;
+        assert((doTest<T, U>(UA_AllocArg, UA_AllocLast, std::move(p))));
+    }
+    {
+        using T = UsesAllocatorV2<Alloc, 1>;
+        using U = UsesAllocatorV3<Alloc, 1>;
+        assert((doTest<T, U>(UA_AllocLast, UA_AllocArg, std::move(p))));
+    }
+    {
+        using T = UsesAllocatorV3<Alloc, 1>;
+        using U = NotUsesAllocator<Alloc, 1>;
+        assert((doTest<T, U>(UA_AllocArg, UA_None, std::move(p))));
+    }
+}
+
+int main()
+{
+    using ERT = std::experimental::erased_type;
+    using PMR = ex::memory_resource*;
+    using PMA = ex::polymorphic_allocator<char>;
+    {
+        int x = 42;
+        int y = 42;
+        std::pair<int&, int&&> p(x, std::move(y));
+        test_pmr_uses_allocator<ERT>(std::move(p));
+        test_pmr_uses_allocator<PMR>(std::move(p));
+        test_pmr_uses_allocator<PMA>(std::move(p));
+    }
+    {
+        int x = 42;
+        int y = 42;
+        std::pair<int&&, int&> p(std::move(x), y);
+        test_pmr_uses_allocator<ERT>(std::move(p));
+        test_pmr_uses_allocator<PMR>(std::move(p));
+        test_pmr_uses_allocator<PMA>(std::move(p));
+    }
+}
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_values.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_values.pass.cpp
new file mode 100644
index 000000000000..a913742a854b
--- /dev/null
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_values.pass.cpp
@@ -0,0 +1,110 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++experimental
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// template <class P1, class P2, class U1, class U2>
+// void polymorphic_allocator<T>::construct(pair<P1, P2>*, U1&&, U2&&)
+
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <utility>
+#include <tuple>
+#include <cassert>
+#include <cstdlib>
+#include "uses_alloc_types.hpp"
+
+namespace ex = std::experimental::pmr;
+
+
+template <class UA1, class UA2, class TT, class UU>
+bool doTest(UsesAllocatorType TExpect, UsesAllocatorType UExpect,
+            TT&& t, UU&& u)
+{
+    using P = std::pair<UA1, UA2>;
+    TestResource R;
+    ex::memory_resource * M = &R;
+    ex::polymorphic_allocator<P> A(M);
+    P * ptr = (P*)std::malloc(sizeof(P));
+    P * ptr2 = (P*)std::malloc(sizeof(P));
+
+    // UNDER TEST //
+    A.construct(ptr, std::forward<TT>(t), std::forward<UU>(u));
+    A.construct(ptr2, std::piecewise_construct,
+                      std::forward_as_tuple(std::forward<TT>(t)),
+                      std::forward_as_tuple(std::forward<UU>(u)));
+    // ------- //
+
+    bool tres = checkConstruct<TT&&>(ptr->first, TExpect, M) &&
+                checkConstructionEquiv(ptr->first, ptr2->first);
+
+    bool ures = checkConstruct<UU&&>(ptr->second, UExpect, M) &&
+                checkConstructionEquiv(ptr->second, ptr2->second);
+
+    A.destroy(ptr);
+    A.destroy(ptr2);
+    std::free(ptr);
+    std::free(ptr2);
+    return tres && ures;
+}
+
+template <class Alloc, class TT, class UU>
+void test_pmr_uses_allocator(TT&& t, UU&& u)
+{
+    {
+        using T = NotUsesAllocator<Alloc, 1>;
+        using U = NotUsesAllocator<Alloc, 1>;
+        assert((doTest<T, U>(UA_None, UA_None,
+                             std::forward<TT>(t), std::forward<UU>(u))));
+    }
+    {
+        using T = UsesAllocatorV1<Alloc, 1>;
+        using U = UsesAllocatorV2<Alloc, 1>;
+        assert((doTest<T, U>(UA_AllocArg, UA_AllocLast,
+                             std::forward<TT>(t), std::forward<UU>(u))));
+    }
+    {
+        using T = UsesAllocatorV2<Alloc, 1>;
+        using U = UsesAllocatorV3<Alloc, 1>;
+        assert((doTest<T, U>(UA_AllocLast, UA_AllocArg,
+                             std::forward<TT>(t), std::forward<UU>(u))));
+    }
+    {
+        using T = UsesAllocatorV3<Alloc, 1>;
+        using U = NotUsesAllocator<Alloc, 1>;
+        assert((doTest<T, U>(UA_AllocArg, UA_None,
+                             std::forward<TT>(t), std::forward<UU>(u))));
+    }
+}
+
+int main()
+{
+    using ERT = std::experimental::erased_type;
+    using PMR = ex::memory_resource*;
+    using PMA = ex::polymorphic_allocator<char>;
+    {
+        int x = 42;
+        int y = 42;
+        test_pmr_uses_allocator<ERT>(x, std::move(y));
+        test_pmr_uses_allocator<PMR>(x, std::move(y));
+        test_pmr_uses_allocator<PMA>(x, std::move(y));
+    }
+    {
+        int x = 42;
+        const int y = 42;
+        test_pmr_uses_allocator<ERT>(std::move(x), y);
+        test_pmr_uses_allocator<PMR>(std::move(x), y);
+        test_pmr_uses_allocator<PMA>(std::move(x), y);
+    }
+}
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp
new file mode 100644
index 000000000000..d0d76503da50
--- /dev/null
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp
@@ -0,0 +1,130 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++experimental
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// template <class U1, class U2, class ...Args1, class ...Args2>
+// void polymorphic_allocator<T>::construct(pair<U1, U2>*, piecewise_construct_t
+//                                          tuple<Args1...>, tuple<Args2...>)
+
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <utility>
+#include <tuple>
+#include <cassert>
+#include <cstdlib>
+#include "uses_alloc_types.hpp"
+#include "test_allocator.h"
+
+namespace ex = std::experimental::pmr;
+
+template <class T, class U, class ...TTuple, class ...UTuple>
+bool doTest(UsesAllocatorType TExpect, UsesAllocatorType UExpect,
+            std::tuple<TTuple...> ttuple, std::tuple<UTuple...> utuple)
+{
+    using P = std::pair<T, U>;
+    TestResource R;
+    ex::memory_resource * M = &R;
+    ex::polymorphic_allocator<P> A(M);
+    P * ptr = A.allocate(1);
+
+    // UNDER TEST //
+    A.construct(ptr, std::piecewise_construct, std::move(ttuple), std::move(utuple));
+    // ------- //
+    bool tres = checkConstruct<TTuple&&...>(ptr->first, TExpect, M);
+    bool ures = checkConstruct<UTuple&&...>(ptr->second, UExpect, M);
+
+    A.destroy(ptr);
+    A.deallocate(ptr, 1);
+    return tres && ures;
+}
+
+template <class Alloc, class ...TTypes, class ...UTypes>
+void test_pmr_uses_allocator(std::tuple<TTypes...> ttuple, std::tuple<UTypes...> utuple)
+{
+    {
+        using T = NotUsesAllocator<Alloc, sizeof...(TTypes)>;
+        using U = NotUsesAllocator<Alloc, sizeof...(UTypes)>;
+        assert((doTest<T, U>(UA_None, UA_None,
+                             std::move(ttuple), std::move(utuple))));
+    }
+    {
+        using T = UsesAllocatorV1<Alloc, sizeof...(TTypes)>;
+        using U = UsesAllocatorV2<Alloc, sizeof...(UTypes)>;
+        assert((doTest<T, U>(UA_AllocArg, UA_AllocLast,
+                             std::move(ttuple), std::move(utuple))));
+    }
+    {
+        using T = UsesAllocatorV2<Alloc, sizeof...(TTypes)>;
+        using U = UsesAllocatorV3<Alloc, sizeof...(UTypes)>;
+        assert((doTest<T, U>(UA_AllocLast, UA_AllocArg,
+                             std::move(ttuple), std::move(utuple))));
+    }
+    {
+        using T = UsesAllocatorV3<Alloc, sizeof...(TTypes)>;
+        using U = NotUsesAllocator<Alloc, sizeof...(UTypes)>;
+        assert((doTest<T, U>(UA_AllocArg, UA_None,
+                             std::move(ttuple), std::move(utuple))));
+    }
+}
+
+int main()
+{
+    using ERT = std::experimental::erased_type;
+    using PMR = ex::memory_resource*;
+    using PMA = ex::polymorphic_allocator<char>;
+    {
+        std::tuple<> t1;
+        test_pmr_uses_allocator<ERT>(t1, t1);
+        test_pmr_uses_allocator<PMR>(t1, t1);
+        test_pmr_uses_allocator<PMA>(t1, t1);
+    }
+    {
+        std::tuple<int> t1(42);
+        std::tuple<> t2;
+        test_pmr_uses_allocator<ERT>(t1, t2);
+        test_pmr_uses_allocator<ERT>(t2, t1);
+        test_pmr_uses_allocator<PMR>(t1, t2);
+        test_pmr_uses_allocator<PMR>(t2, t1);
+        test_pmr_uses_allocator<PMA>(t1, t2);
+        test_pmr_uses_allocator<PMA>(t2, t1);
+    }
+    {
+        std::tuple<int> t1(42);
+        int x = 55;
+        double dx = 42.42;
+        std::tuple<int&, double&&> t2(x, std::move(dx));
+        test_pmr_uses_allocator<ERT>(           t1, std::move(t2));
+        test_pmr_uses_allocator<ERT>(std::move(t2),            t1);
+        test_pmr_uses_allocator<PMR>(           t1, std::move(t2));
+        test_pmr_uses_allocator<PMR>(std::move(t2),            t1);
+        test_pmr_uses_allocator<PMA>(           t1, std::move(t2));
+        test_pmr_uses_allocator<PMA>(std::move(t2),            t1);
+    }
+    {
+        void* xptr = nullptr;
+        long y = 4242;
+        std::tuple<int, long const&, void*&> t1(42, y, xptr);
+        int x = 55;
+        double dx = 42.42;
+        const char* s = "hello World";
+        std::tuple<int&, double&&, const char*> t2(x, std::move(dx), s);
+        test_pmr_uses_allocator<ERT>(           t1, std::move(t2));
+        test_pmr_uses_allocator<ERT>(std::move(t2),            t1);
+        test_pmr_uses_allocator<PMR>(           t1, std::move(t2));
+        test_pmr_uses_allocator<PMR>(std::move(t2),            t1);
+        test_pmr_uses_allocator<PMA>(           t1, std::move(t2));
+        test_pmr_uses_allocator<PMA>(std::move(t2),            t1);
+    }
+}
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_types.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_types.pass.cpp
new file mode 100644
index 000000000000..73e4f0e101a8
--- /dev/null
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_types.pass.cpp
@@ -0,0 +1,190 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++experimental
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// template <class U, class ...Args>
+// void polymorphic_allocator<T>::construct(U *, Args &&...)
+
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <cassert>
+#include <cstdlib>
+#include "uses_alloc_types.hpp"
+#include "test_allocator.h"
+
+namespace ex = std::experimental::pmr;
+
+template <class T>
+struct PMATest {
+    TestResource R;
+    ex::polymorphic_allocator<T> A;
+    T* ptr;
+    bool constructed;
+
+    PMATest() : A(&R), ptr(A.allocate(1)), constructed(false) {}
+
+    template <class ...Args>
+    void construct(Args&&... args) {
+        A.construct(ptr, std::forward<Args>(args)...);
+        constructed = true;
+    }
+
+    ~PMATest() {
+        if (constructed) A.destroy(ptr);
+        A.deallocate(ptr, 1);
+    }
+};
+
+template <class T, class ...Args>
+bool doTest(UsesAllocatorType UAExpect, Args&&... args)
+{
+    PMATest<T> TH;
+    // UNDER TEST //
+    TH.construct(std::forward<Args>(args)...);
+    return checkConstruct<Args&&...>(*TH.ptr, UAExpect, &TH.R);
+    // ------- //
+}
+
+
+template <class T, class ...Args>
+bool doTestUsesAllocV0(Args&&... args)
+{
+    PMATest<T> TH;
+    // UNDER TEST //
+    TH.construct(std::forward<Args>(args)...);
+    return checkConstruct<Args&&...>(*TH.ptr, UA_None);
+    // -------- //
+}
+
+
+template <class T, class EAlloc, class ...Args>
+bool doTestUsesAllocV1(EAlloc const& ealloc, Args&&... args)
+{
+    PMATest<T> TH;
+    // UNDER TEST //
+    TH.construct(std::allocator_arg, ealloc, std::forward<Args>(args)...);
+    return checkConstruct<Args&&...>(*TH.ptr, UA_AllocArg, ealloc);
+    // -------- //
+}
+
+template <class T, class EAlloc, class ...Args>
+bool doTestUsesAllocV2(EAlloc const& ealloc, Args&&... args)
+{
+    PMATest<T> TH;
+    // UNDER TEST //
+    TH.construct(std::forward<Args>(args)..., ealloc);
+    return checkConstruct<Args&&...>(*TH.ptr, UA_AllocLast, ealloc);
+    // -------- //
+}
+
+template <class Alloc, class ...Args>
+void test_pmr_uses_alloc(Args&&... args)
+{
+    TestResource R(12435);
+    ex::memory_resource* M = &R;
+    {
+        // NotUsesAllocator provides valid signatures for each uses-allocator
+        // construction but does not supply the required allocator_type typedef.
+        // Test that we can call these constructors manually without
+        // polymorphic_allocator interfering.
+        using T = NotUsesAllocator<Alloc, sizeof...(Args)>;
+        assert(doTestUsesAllocV0<T>(std::forward<Args>(args)...));
+        assert((doTestUsesAllocV1<T>(M, std::forward<Args>(args)...)));
+        assert((doTestUsesAllocV2<T>(M, std::forward<Args>(args)...)));
+    }
+    {
+        // Test T(std::allocator_arg_t, Alloc const&, Args...) construction
+        using T = UsesAllocatorV1<Alloc, sizeof...(Args)>;
+        assert((doTest<T>(UA_AllocArg, std::forward<Args>(args)...)));
+    }
+    {
+        // Test T(Args..., Alloc const&) construction
+        using T = UsesAllocatorV2<Alloc, sizeof...(Args)>;
+        assert((doTest<T>(UA_AllocLast, std::forward<Args>(args)...)));
+    }
+    {
+        // Test that T(std::allocator_arg_t, Alloc const&, Args...) construction
+        // is prefered when T(Args..., Alloc const&) is also available.
+        using T = UsesAllocatorV3<Alloc, sizeof...(Args)>;
+        assert((doTest<T>(UA_AllocArg, std::forward<Args>(args)...)));
+    }
+}
+
+// Test that polymorphic_allocator does not prevent us from manually
+// doing non-pmr uses-allocator construction.
+template <class Alloc, class AllocObj, class ...Args>
+void test_non_pmr_uses_alloc(AllocObj const& A, Args&&... args)
+{
+    {
+        using T = NotUsesAllocator<Alloc, sizeof...(Args)>;
+        assert(doTestUsesAllocV0<T>(std::forward<Args>(args)...));
+        assert((doTestUsesAllocV1<T>(A, std::forward<Args>(args)...)));
+        assert((doTestUsesAllocV2<T>(A, std::forward<Args>(args)...)));
+    }
+    {
+        using T = UsesAllocatorV1<Alloc, sizeof...(Args)>;
+        assert(doTestUsesAllocV0<T>(std::forward<Args>(args)...));
+        assert((doTestUsesAllocV1<T>(A, std::forward<Args>(args)...)));
+    }
+    {
+        using T = UsesAllocatorV2<Alloc, sizeof...(Args)>;
+        assert(doTestUsesAllocV0<T>(std::forward<Args>(args)...));
+        assert((doTestUsesAllocV2<T>(A, std::forward<Args>(args)...)));
+    }
+    {
+        using T = UsesAllocatorV3<Alloc, sizeof...(Args)>;
+        assert(doTestUsesAllocV0<T>(std::forward<Args>(args)...));
+        assert((doTestUsesAllocV1<T>(A, std::forward<Args>(args)...)));
+        assert((doTestUsesAllocV2<T>(A, std::forward<Args>(args)...)));
+    }
+}
+
+int main()
+{
+    using ET = std::experimental::erased_type;
+    using PMR = ex::memory_resource*;
+    using PMA = ex::polymorphic_allocator<void>;
+    using STDA = std::allocator<char>;
+    using TESTA = test_allocator<char>;
+
+    int value = 42;
+    const int cvalue = 43;
+    {
+        test_pmr_uses_alloc<ET>();
+        test_pmr_uses_alloc<PMR>();
+        test_pmr_uses_alloc<PMA>();
+        test_pmr_uses_alloc<ET>(value);
+        test_pmr_uses_alloc<PMR>(value);
+        test_pmr_uses_alloc<PMA>(value);
+        test_pmr_uses_alloc<ET>(cvalue);
+        test_pmr_uses_alloc<PMR>(cvalue);
+        test_pmr_uses_alloc<PMA>(cvalue);
+        test_pmr_uses_alloc<ET>(cvalue, std::move(value));
+        test_pmr_uses_alloc<PMR>(cvalue, std::move(value));
+        test_pmr_uses_alloc<PMA>(cvalue, std::move(value));
+    }
+    {
+        STDA std_alloc;
+        TESTA test_alloc(42);
+        test_non_pmr_uses_alloc<STDA>(std_alloc);
+        test_non_pmr_uses_alloc<TESTA>(test_alloc);
+        test_non_pmr_uses_alloc<STDA>(std_alloc, value);
+        test_non_pmr_uses_alloc<TESTA>(test_alloc, value);
+        test_non_pmr_uses_alloc<STDA>(std_alloc, cvalue);
+        test_non_pmr_uses_alloc<TESTA>(test_alloc, cvalue);
+        test_non_pmr_uses_alloc<STDA>(std_alloc, cvalue, std::move(value));
+        test_non_pmr_uses_alloc<TESTA>(test_alloc, cvalue, std::move(value));
+    }
+}
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/deallocate.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/deallocate.pass.cpp
new file mode 100644
index 000000000000..d60c2f2d90f6
--- /dev/null
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/deallocate.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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++experimental
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// T* polymorphic_allocator<T>::deallocate(T*, size_t size)
+
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <cassert>
+
+#include "test_memory_resource.hpp"
+
+namespace ex = std::experimental::pmr;
+
+template <size_t S, size_t Align>
+void testForSizeAndAlign() {
+    using T = typename std::aligned_storage<S, Align>::type;
+
+    TestResource R;
+    ex::polymorphic_allocator<T> a(&R);
+
+    for (int N = 1; N <= 5; ++N) {
+        auto ret = a.allocate(N);
+        assert(R.checkAlloc(ret, N * sizeof(T), alignof(T)));
+
+        a.deallocate(ret, N);
+        assert(R.checkDealloc(ret, N * sizeof(T), alignof(T)));
+
+        R.reset();
+    }
+}
+
+int main()
+{
+    {
+        ex::polymorphic_allocator<int> a;
+        static_assert(
+            std::is_same<decltype(a.deallocate(nullptr, 0)), void>::value, "");
+    }
+    {
+        constexpr std::size_t MA = alignof(std::max_align_t);
+        testForSizeAndAlign<1, 1>();
+        testForSizeAndAlign<1, 2>();
+        testForSizeAndAlign<1, MA>();
+        testForSizeAndAlign<2, 2>();
+        testForSizeAndAlign<73, alignof(void*)>();
+        testForSizeAndAlign<73, MA>();
+        testForSizeAndAlign<13, MA>();
+    }
+}
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/destroy.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/destroy.pass.cpp
new file mode 100644
index 000000000000..5d907660dce2
--- /dev/null
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/destroy.pass.cpp
@@ -0,0 +1,52 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++experimental
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// template <class U>
+// void polymorphic_allocator<T>::destroy(U * ptr);
+
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <new>
+#include <cassert>
+#include <cstdlib>
+
+namespace ex = std::experimental::pmr;
+
+int count = 0;
+
+struct destroyable
+{
+    destroyable() { ++count; }
+    ~destroyable() { --count; }
+};
+
+int main()
+{
+    typedef ex::polymorphic_allocator<double> A;
+    {
+        A a;
+        static_assert(
+            std::is_same<decltype(a.destroy((destroyable*)nullptr)), void>::value,
+            "");
+    }
+    {
+        destroyable * ptr = ::new (std::malloc(sizeof(destroyable))) destroyable();
+        assert(count == 1);
+        A{}.destroy(ptr);
+        assert(count == 0);
+        std::free(ptr);
+    }
+}
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/resource.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/resource.pass.cpp
new file mode 100644
index 000000000000..b59606b9e80d
--- /dev/null
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/resource.pass.cpp
@@ -0,0 +1,57 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++experimental
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// memory_resource *
+// polymorphic_allocator<T>::resource() const
+
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <cassert>
+
+namespace ex = std::experimental::pmr;
+
+int main()
+{
+    typedef ex::polymorphic_allocator<void> A;
+    {
+        A const a;
+        static_assert(
+            std::is_same<decltype(a.resource()), ex::memory_resource*>::value
+          , ""
+          );
+    }
+    {
+        ex::memory_resource * mptr = (ex::memory_resource*)42;
+        A const a(mptr);
+        assert(a.resource() == mptr);
+    }
+    {
+        A const a(nullptr);
+        assert(a.resource() == nullptr);
+        assert(a.resource() == nullptr);
+    }
+    {
+        A const a;
+        assert(a.resource() == ex::get_default_resource());
+    }
+    {
+        ex::memory_resource * mptr = (ex::memory_resource*)42;
+        ex::set_default_resource(mptr);
+        A const a;
+        assert(a.resource() == mptr);
+        assert(a.resource() == ex::get_default_resource());
+    }
+}
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/select_on_container_copy_construction.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/select_on_container_copy_construction.pass.cpp
new file mode 100644
index 000000000000..353fcafed740
--- /dev/null
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/select_on_container_copy_construction.pass.cpp
@@ -0,0 +1,53 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++experimental
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/memory_resource>
+
+// template <class T> class polymorphic_allocator
+
+// polymorphic_allocator
+// polymorphic_allocator<T>::select_on_container_copy_construction() const
+
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <cassert>
+
+namespace ex = std::experimental::pmr;
+
+int main()
+{
+    typedef ex::polymorphic_allocator<void> A;
+    {
+        A const a;
+        static_assert(
+            std::is_same<decltype(a.select_on_container_copy_construction()), A>::value,
+            "");
+    }
+    {
+        ex::memory_resource * mptr = (ex::memory_resource*)42;
+        A const a(mptr);
+        assert(a.resource() == mptr);
+        A const other = a.select_on_container_copy_construction();
+        assert(other.resource() == ex::get_default_resource());
+        assert(a.resource() == mptr);
+    }
+    {
+        ex::memory_resource * mptr = (ex::memory_resource*)42;
+        ex::set_default_resource(mptr);
+        A const a(nullptr);
+        assert(a.resource() == nullptr);
+        A const other = a.select_on_container_copy_construction();
+        assert(other.resource() == ex::get_default_resource());
+        assert(other.resource() == mptr);
+        assert(a.resource() == nullptr);
+    }
+}
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.overview/nothing_to_do.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.overview/nothing_to_do.pass.cpp
new file mode 100644
index 000000000000..86bf8cc11bb9
--- /dev/null
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.overview/nothing_to_do.pass.cpp
@@ -0,0 +1,10 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+int main () {}
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/nothing_to_do.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/nothing_to_do.pass.cpp
new file mode 100644
index 000000000000..86bf8cc11bb9
--- /dev/null
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/nothing_to_do.pass.cpp
@@ -0,0 +1,10 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+int main () {}
diff --git a/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_copy.pass.cpp b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_copy.pass.cpp
new file mode 100644
index 000000000000..4de30bccb816
--- /dev/null
+++ b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_copy.pass.cpp
@@ -0,0 +1,53 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/memory_resource>
+
+// template <class Alloc> class resource_adaptor_imp;
+
+// resource_adaptor_imp<Alloc>::resource_adaptor_imp(Alloc const &)
+
+#include <experimental/memory_resource>
+#include <cassert>
+
+#include "test_memory_resource.hpp"
+
+namespace ex = std::experimental::pmr;
+
+int main()
+{
+    typedef CountingAllocator<char> AllocT;
+    typedef ex::resource_adaptor<AllocT> R;
+    {
+        AllocController P;
+        AllocT const a(P);
+        R const r(a);
+        assert(P.copy_constructed == 1);
+        assert(P.move_constructed == 0);
+        assert(r.get_allocator() == a);
+    }
+    {
+        AllocController P;
+        AllocT a(P);
+        R const r(a);
+        assert(P.copy_constructed == 1);
+        assert(P.move_constructed == 0);
+        assert(r.get_allocator() == a);
+    }
+    {
+        AllocController P;
+        AllocT const a(P);
+        R const r(std::move(a));
+        assert(P.copy_constructed == 1);
+        assert(P.move_constructed == 0);
+        assert(r.get_allocator() == a);
+    }
+}
diff --git a/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_move.pass.cpp b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_move.pass.cpp
new file mode 100644
index 000000000000..f3ecc98eeaa9
--- /dev/null
+++ b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_move.pass.cpp
@@ -0,0 +1,44 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/memory_resource>
+
+// template <class Alloc> class resource_adaptor_imp;
+
+// resource_adaptor_imp<Alloc>::resource_adaptor_imp(Alloc &&)
+
+#include <experimental/memory_resource>
+#include <cassert>
+
+#include "test_memory_resource.hpp"
+
+namespace ex = std::experimental::pmr;
+
+int main()
+{
+    typedef CountingAllocator<char> AllocT;
+    typedef ex::resource_adaptor<AllocT> R;
+    {
+        AllocController P;
+        AllocT a(P);
+        R const r(std::move(a));
+        assert(P.copy_constructed == 0);
+        assert(P.move_constructed == 1);
+        assert(r.get_allocator() == a);
+    }
+    {
+        AllocController P;
+        R const r(AllocT{P});
+        assert(P.copy_constructed == 0);
+        assert(P.move_constructed == 1);
+        assert(r.get_allocator() == AllocT{P});
+    }
+}
diff --git a/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/default.pass.cpp b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/default.pass.cpp
new file mode 100644
index 000000000000..4abc69f0b3d1
--- /dev/null
+++ b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/default.pass.cpp
@@ -0,0 +1,40 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/memory_resource>
+
+// template <class Alloc> class resource_adaptor_imp;
+
+// resource_adaptor_imp<Alloc>::resource_adaptor_imp() = default;
+
+#include <experimental/memory_resource>
+#include <memory>
+#include <type_traits>
+#include <cassert>
+
+#include "test_memory_resource.hpp"
+
+namespace ex = std::experimental::pmr;
+
+int main()
+{
+    {
+        typedef CountingAllocator<char> AllocT; // Not default constructible
+        typedef ex::resource_adaptor<AllocT> R;
+        static_assert(!std::is_default_constructible<R>::value, "");
+    }
+    {
+        typedef std::allocator<char> AllocT; // Is default constructible
+        typedef ex::resource_adaptor<AllocT> R;
+        static_assert(std::is_default_constructible<R>::value, "");
+        R r; ((void)r);
+    }
+}
diff --git a/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_allocate_and_deallocate.pass.cpp b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_allocate_and_deallocate.pass.cpp
new file mode 100644
index 000000000000..16b72697593d
--- /dev/null
+++ b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_allocate_and_deallocate.pass.cpp
@@ -0,0 +1,115 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/memory_resource>
+
+// template <class Alloc> class resource_adaptor_imp;
+
+// void * do_allocate(size_t size, size_t align)
+// void   do_deallocate(void*, size_t, size_t)
+
+
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <memory>
+#include <exception>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_memory_resource.hpp"
+
+namespace ex = std::experimental::pmr;
+
+template <class Alloc>
+void check_allocate_deallocate()
+{
+    typedef ex::resource_adaptor<Alloc> R1;
+    const std::size_t max_align = alignof(std::max_align_t);
+
+    for (std::size_t s = 1; s < 5012; ++s)
+    {
+        for(std::size_t align_req = 1; align_req <= (max_align * 2); align_req *= 2)
+        {
+            const std::size_t align_exp = align_req > max_align
+                                                    ? max_align : align_req;
+            AllocController P;
+            R1 r{Alloc(P)};
+            ex::memory_resource & m1 = r;
+
+            void * const ret = m1.allocate(s, align_req);
+            assert(P.alive == 1);
+            assert(P.alloc_count == 1);
+            assert(P.checkAllocAtLeast(ret, s, align_exp));
+
+            assert(((std::size_t)ret % align_exp) == 0);
+
+            m1.deallocate(ret, s, align_req);
+            assert(P.alive == 0);
+            assert(P.dealloc_count == 1);
+            assert(P.checkDeallocMatchesAlloc());
+        }
+    }
+}
+
+void check_alloc_max_size() {
+    using Alloc = NullAllocator<char>;
+    using R1 = ex::resource_adaptor<Alloc>;
+    const std::size_t max_align = alignof(std::max_align_t);
+
+    auto check = [=](std::size_t s, std::size_t align_req) {
+        const std::size_t align_exp = align_req > max_align
+                                                ? max_align : align_req;
+        AllocController P;
+        R1 r{Alloc(P)};
+        ex::memory_resource & m1 = r;
+
+        void * const ret = m1.allocate(s, align_req);
+        assert(P.alive == 1);
+        assert(P.alloc_count == 1);
+        assert(P.checkAllocAtLeast(ret, s, align_exp));
+
+        m1.deallocate(ret, s, align_req);
+        assert(P.alive == 0);
+        assert(P.dealloc_count == 1);
+        assert(P.checkDeallocMatchesAlloc());
+    };
+
+    const std::size_t sizeTypeMax = ~0;
+    const std::size_t testSizeStart = sizeTypeMax - (max_align * 3);
+    const std::size_t testSizeEnd = sizeTypeMax - max_align;
+
+    for (std::size_t size = testSizeStart; size <= testSizeEnd; ++size) {
+        for (std::size_t align=1; align <= (max_align * 2); align *= 2) {
+            check(size, align);
+        }
+    }
+
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    for (std::size_t size = sizeTypeMax; size > testSizeEnd; --size) {
+        AllocController P;
+        R1 r{Alloc(P)};
+        ex::memory_resource & m1 = r;
+
+        try {
+            m1.allocate(size);
+            assert(false);
+        } catch (std::exception const&) {
+        }
+    }
+#endif
+}
+
+int main()
+{
+    check_allocate_deallocate<CountingAllocator<char>>();
+    check_allocate_deallocate<MinAlignedAllocator<char>>();
+    check_alloc_max_size();
+}
diff --git a/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_is_equal.pass.cpp b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_is_equal.pass.cpp
new file mode 100644
index 000000000000..ff4b3179a42a
--- /dev/null
+++ b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_is_equal.pass.cpp
@@ -0,0 +1,83 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/memory_resource>
+
+// template <class Alloc> class resource_adaptor_imp;
+
+// bool do_is_equal(memory_resource const &) const noexcept;
+
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <memory>
+#include <cassert>
+#include "test_memory_resource.hpp"
+
+using std::size_t;
+namespace ex = std::experimental::pmr;
+
+int main()
+{
+
+    typedef CountingAllocator<char> Alloc1;
+    typedef CountingAllocator<int> RAlloc1;
+    typedef ex::resource_adaptor<Alloc1> R1;
+    typedef ex::resource_adaptor<RAlloc1> RR1;
+    static_assert(std::is_same<R1, RR1>::value, "");
+
+    typedef std::allocator<char> Alloc2;
+    typedef ex::resource_adaptor<Alloc2> R2;
+    static_assert(!std::is_same<R1, R2>::value, "");
+
+    // equal same type
+    {
+        AllocController C;
+        Alloc1 a1(C);
+        R1 const r1(a1);
+        ex::memory_resource const & m1 = r1;
+
+        Alloc1 a2(C);
+        R1 const r2(a2);
+        ex::memory_resource const & m2 = r2;
+
+        assert(m1.is_equal(m2));
+        assert(m2.is_equal(m1));
+    }
+    // not equal same type
+    {
+        AllocController C;
+        Alloc1 a1(C);
+        R1 const r1(a1);
+        ex::memory_resource const & m1 = r1;
+
+        AllocController C2;
+        Alloc1 a2(C2);
+        R1 const r2(a2);
+        ex::memory_resource const & m2 = r2;
+
+        assert(!m1.is_equal(m2));
+        assert(!m2.is_equal(m1));
+    }
+    // different allocator types
+    {
+        AllocController C;
+        Alloc1 a1(C);
+        R1 const r1(a1);
+        ex::memory_resource const & m1 = r1;
+
+        Alloc2 a2;
+        R2 const r2(a2);
+        ex::memory_resource const & m2 = r2;
+
+        assert(!m1.is_equal(m2));
+        assert(!m2.is_equal(m1));
+    }
+}
diff --git a/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.overview/overview.pass.cpp b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.overview/overview.pass.cpp
new file mode 100644
index 000000000000..898543fbce4b
--- /dev/null
+++ b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.overview/overview.pass.cpp
@@ -0,0 +1,39 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/memory_resource>
+
+// template <class Alloc> class resource_adaptor_imp;
+
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <memory>
+#include <cassert>
+
+namespace ex = std::experimental::pmr;
+
+int main()
+{
+    typedef ex::resource_adaptor<std::allocator<void>> R;
+    typedef ex::resource_adaptor<std::allocator<long>> R2;
+    static_assert(std::is_same<R, R2>::value, "");
+    {
+        static_assert(std::is_base_of<ex::memory_resource, R>::value, "");
+        static_assert(std::is_same<R::allocator_type, std::allocator<char>>::value, "");
+    }
+    {
+        static_assert(std::is_default_constructible<R>::value, "");
+        static_assert(std::is_copy_constructible<R>::value, "");
+        static_assert(std::is_move_constructible<R>::value, "");
+        static_assert(std::is_copy_assignable<R>::value, "");
+        static_assert(std::is_move_assignable<R>::value, "");
+   }
+}
diff --git a/test/std/experimental/memory/memory.resource.aliases/header_deque_synop.pass.cpp b/test/std/experimental/memory/memory.resource.aliases/header_deque_synop.pass.cpp
new file mode 100644
index 000000000000..5654a785aebb
--- /dev/null
+++ b/test/std/experimental/memory/memory.resource.aliases/header_deque_synop.pass.cpp
@@ -0,0 +1,37 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++experimental
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/deque>
+
+// namespace std { namespace experimental { namespace pmr {
+// template <class T>
+// using deque =
+//     ::std::deque<T, polymorphic_allocator<T>>
+//
+// }}} // namespace std::experimental::pmr
+
+#include <experimental/deque>
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <cassert>
+
+namespace pmr = std::experimental::pmr;
+
+int main()
+{
+    using StdDeque = std::deque<int, pmr::polymorphic_allocator<int>>;
+    using PmrDeque = pmr::deque<int>;
+    static_assert(std::is_same<StdDeque, PmrDeque>::value, "");
+    PmrDeque d;
+    assert(d.get_allocator().resource() == pmr::get_default_resource());
+}
diff --git a/test/std/experimental/memory/memory.resource.aliases/header_forward_list_synop.pass.cpp b/test/std/experimental/memory/memory.resource.aliases/header_forward_list_synop.pass.cpp
new file mode 100644
index 000000000000..e834be3912f9
--- /dev/null
+++ b/test/std/experimental/memory/memory.resource.aliases/header_forward_list_synop.pass.cpp
@@ -0,0 +1,37 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++experimental
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/forward_list>
+
+// namespace std { namespace experimental { namespace pmr {
+// template <class T>
+// using forward_list =
+//     ::std::forward_list<T, polymorphic_allocator<T>>
+//
+// }}} // namespace std::experimental::pmr
+
+#include <experimental/forward_list>
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <cassert>
+
+namespace pmr = std::experimental::pmr;
+
+int main()
+{
+    using StdForwardList = std::forward_list<int, pmr::polymorphic_allocator<int>>;
+    using PmrForwardList = pmr::forward_list<int>;
+    static_assert(std::is_same<StdForwardList, PmrForwardList>::value, "");
+    PmrForwardList d;
+    assert(d.get_allocator().resource() == pmr::get_default_resource());
+}
diff --git a/test/std/experimental/memory/memory.resource.aliases/header_list_synop.pass.cpp b/test/std/experimental/memory/memory.resource.aliases/header_list_synop.pass.cpp
new file mode 100644
index 000000000000..a53b528e877e
--- /dev/null
+++ b/test/std/experimental/memory/memory.resource.aliases/header_list_synop.pass.cpp
@@ -0,0 +1,37 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++experimental
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/list>
+
+// namespace std { namespace experimental { namespace pmr {
+// template <class T>
+// using list =
+//     ::std::list<T, polymorphic_allocator<T>>
+//
+// }}} // namespace std::experimental::pmr
+
+#include <experimental/list>
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <cassert>
+
+namespace pmr = std::experimental::pmr;
+
+int main()
+{
+    using StdList = std::list<int, pmr::polymorphic_allocator<int>>;
+    using PmrList = pmr::list<int>;
+    static_assert(std::is_same<StdList, PmrList>::value, "");
+    PmrList d;
+    assert(d.get_allocator().resource() == pmr::get_default_resource());
+}
diff --git a/test/std/experimental/memory/memory.resource.aliases/header_map_synop.pass.cpp b/test/std/experimental/memory/memory.resource.aliases/header_map_synop.pass.cpp
new file mode 100644
index 000000000000..4996d4e6dd25
--- /dev/null
+++ b/test/std/experimental/memory/memory.resource.aliases/header_map_synop.pass.cpp
@@ -0,0 +1,69 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++experimental
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/map>
+
+// namespace std { namespace experimental { namespace pmr {
+// template <class K, class V, class Compare = less<Key> >
+// using map =
+//     ::std::map<K, V, Compare, polymorphic_allocator<pair<const K, V>>>
+//
+// template <class K, class V, class Compare = less<Key> >
+// using multimap =
+//     ::std::multimap<K, V, Compare, polymorphic_allocator<pair<const K, V>>>
+//
+// }}} // namespace std::experimental::pmr
+
+#include <experimental/map>
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <cassert>
+
+namespace pmr = std::experimental::pmr;
+
+int main()
+{
+    using K = int;
+    using V = char;
+    using DC = std::less<int>;
+    using OC = std::greater<int>;
+    using P = std::pair<const K, V>;
+    {
+        using StdMap = std::map<K, V, DC, pmr::polymorphic_allocator<P>>;
+        using PmrMap = pmr::map<K, V>;
+        static_assert(std::is_same<StdMap, PmrMap>::value, "");
+    }
+    {
+        using StdMap = std::map<K, V, OC, pmr::polymorphic_allocator<P>>;
+        using PmrMap = pmr::map<K, V, OC>;
+        static_assert(std::is_same<StdMap, PmrMap>::value, "");
+    }
+    {
+        pmr::map<int, int> m;
+        assert(m.get_allocator().resource() == pmr::get_default_resource());
+    }
+    {
+        using StdMap = std::multimap<K, V, DC, pmr::polymorphic_allocator<P>>;
+        using PmrMap = pmr::multimap<K, V>;
+        static_assert(std::is_same<StdMap, PmrMap>::value, "");
+    }
+    {
+        using StdMap = std::multimap<K, V, OC, pmr::polymorphic_allocator<P>>;
+        using PmrMap = pmr::multimap<K, V, OC>;
+        static_assert(std::is_same<StdMap, PmrMap>::value, "");
+    }
+    {
+        pmr::multimap<int, int> m;
+        assert(m.get_allocator().resource() == pmr::get_default_resource());
+    }
+}
diff --git a/test/std/experimental/memory/memory.resource.aliases/header_regex_synop.pass.cpp b/test/std/experimental/memory/memory.resource.aliases/header_regex_synop.pass.cpp
new file mode 100644
index 000000000000..f371c8a52f1d
--- /dev/null
+++ b/test/std/experimental/memory/memory.resource.aliases/header_regex_synop.pass.cpp
@@ -0,0 +1,57 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++experimental
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/regex>
+
+// namespace std { namespace experimental { namespace pmr {
+//
+//  template <class BidirectionalIterator>
+//  using match_results =
+//    std::match_results<BidirectionalIterator,
+//                       polymorphic_allocator<sub_match<BidirectionalIterator>>>;
+//
+//  typedef match_results<const char*> cmatch;
+//  typedef match_results<const wchar_t*> wcmatch;
+//  typedef match_results<string::const_iterator> smatch;
+//  typedef match_results<wstring::const_iterator> wsmatch;
+//
+// }}} // namespace std::experimental::pmr
+
+#include <experimental/regex>
+#include <type_traits>
+#include <cassert>
+
+namespace pmr = std::experimental::pmr;
+
+template <class Iter, class PmrTypedef>
+void test_match_result_typedef() {
+    using StdMR = std::match_results<Iter, pmr::polymorphic_allocator<std::sub_match<Iter>>>;
+    using PmrMR = pmr::match_results<Iter>;
+    static_assert(std::is_same<StdMR, PmrMR>::value, "");
+    static_assert(std::is_same<PmrMR, PmrTypedef>::value, "");
+}
+
+int main()
+{
+    {
+        test_match_result_typedef<const char*, pmr::cmatch>();
+        test_match_result_typedef<const wchar_t*, pmr::wcmatch>();
+        test_match_result_typedef<pmr::string::const_iterator, pmr::smatch>();
+        test_match_result_typedef<pmr::wstring::const_iterator, pmr::wsmatch>();
+    }
+    {
+        // Check that std::match_results has been included and is complete.
+        pmr::smatch s;
+        assert(s.get_allocator().resource() == pmr::get_default_resource());
+    }
+}
diff --git a/test/std/experimental/memory/memory.resource.aliases/header_set_synop.pass.cpp b/test/std/experimental/memory/memory.resource.aliases/header_set_synop.pass.cpp
new file mode 100644
index 000000000000..3af1d700504e
--- /dev/null
+++ b/test/std/experimental/memory/memory.resource.aliases/header_set_synop.pass.cpp
@@ -0,0 +1,67 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++experimental
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/set>
+
+// namespace std { namespace experimental { namespace pmr {
+// template <class V, class Compare = less<V> >
+// using set =
+//     ::std::set<V, Compare, polymorphic_allocator<V>>
+//
+// template <class V, class Compare = less<V> >
+// using multiset =
+//     ::std::multiset<V, Compare, polymorphic_allocator<V>>
+//
+// }}} // namespace std::experimental::pmr
+
+#include <experimental/set>
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <cassert>
+
+namespace pmr = std::experimental::pmr;
+
+int main()
+{
+    using V = char;
+    using DC = std::less<V>;
+    using OC = std::greater<V>;
+    {
+        using StdSet = std::set<V, DC, pmr::polymorphic_allocator<V>>;
+        using PmrSet = pmr::set<V>;
+        static_assert(std::is_same<StdSet, PmrSet>::value, "");
+    }
+    {
+        using StdSet = std::set<V, OC, pmr::polymorphic_allocator<V>>;
+        using PmrSet = pmr::set<V, OC>;
+        static_assert(std::is_same<StdSet, PmrSet>::value, "");
+    }
+    {
+        pmr::set<int> m;
+        assert(m.get_allocator().resource() == pmr::get_default_resource());
+    }
+    {
+        using StdSet = std::multiset<V, DC, pmr::polymorphic_allocator<V>>;
+        using PmrSet = pmr::multiset<V>;
+        static_assert(std::is_same<StdSet, PmrSet>::value, "");
+    }
+    {
+        using StdSet = std::multiset<V, OC, pmr::polymorphic_allocator<V>>;
+        using PmrSet = pmr::multiset<V, OC>;
+        static_assert(std::is_same<StdSet, PmrSet>::value, "");
+    }
+    {
+        pmr::multiset<int> m;
+        assert(m.get_allocator().resource() == pmr::get_default_resource());
+    }
+}
diff --git a/test/std/experimental/memory/memory.resource.aliases/header_string_synop.pass.cpp b/test/std/experimental/memory/memory.resource.aliases/header_string_synop.pass.cpp
new file mode 100644
index 000000000000..21889c2da3d2
--- /dev/null
+++ b/test/std/experimental/memory/memory.resource.aliases/header_string_synop.pass.cpp
@@ -0,0 +1,73 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++experimental
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/string>
+
+// namespace std { namespace experimental { namespace pmr {
+// template <class Char, class Traits = ...>
+// using basic_string =
+//     ::std::basic_string<Char, Traits, polymorphic_allocator<Char>>
+//
+// typedef ... string
+// typedef ... u16string
+// typedef ... u32string
+// typedef ... wstring
+//
+// }}} // namespace std::experimental::pmr
+
+#include <experimental/string>
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <cassert>
+
+#include "constexpr_char_traits.hpp"
+
+namespace pmr = std::experimental::pmr;
+
+template <class Char, class PmrTypedef>
+void test_string_typedef() {
+    using StdStr = std::basic_string<Char, std::char_traits<Char>,
+                                     pmr::polymorphic_allocator<Char>>;
+    using PmrStr = pmr::basic_string<Char>;
+    static_assert(std::is_same<StdStr, PmrStr>::value, "");
+    static_assert(std::is_same<PmrStr, PmrTypedef>::value, "");
+}
+
+template <class Char, class Traits>
+void test_basic_string_alias() {
+    using StdStr = std::basic_string<Char, Traits,
+                                     pmr::polymorphic_allocator<Char>>;
+    using PmrStr = pmr::basic_string<Char, Traits>;
+    static_assert(std::is_same<StdStr, PmrStr>::value, "");
+}
+
+int main()
+{
+    {
+        test_string_typedef<char,     pmr::string>();
+        test_string_typedef<wchar_t,  pmr::wstring>();
+        test_string_typedef<char16_t, pmr::u16string>();
+        test_string_typedef<char32_t, pmr::u32string>();
+    }
+    {
+        test_basic_string_alias<char,    constexpr_char_traits<char>>();
+        test_basic_string_alias<wchar_t, constexpr_char_traits<wchar_t>>();
+        test_basic_string_alias<char16_t, constexpr_char_traits<char16_t>>();
+        test_basic_string_alias<char32_t, constexpr_char_traits<char32_t>>();
+    }
+    {
+        // Check that std::basic_string has been included and is complete.
+        pmr::string s;
+        assert(s.get_allocator().resource() == pmr::get_default_resource());
+    }
+}
diff --git a/test/std/experimental/memory/memory.resource.aliases/header_unordered_map_synop.pass.cpp b/test/std/experimental/memory/memory.resource.aliases/header_unordered_map_synop.pass.cpp
new file mode 100644
index 000000000000..99c928b7a9fd
--- /dev/null
+++ b/test/std/experimental/memory/memory.resource.aliases/header_unordered_map_synop.pass.cpp
@@ -0,0 +1,87 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++experimental
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/unordered_map>
+
+// namespace std { namespace experimental { namespace pmr {
+// template <class K, class V, class H = hash<K>, class P = equal_to<K> >
+// using unordered_map =
+//     ::std::unordered_map<K, V, H, P, polymorphic_allocator<pair<const K, V>>>
+//
+// template <class K, class V,  class H = hash<K>, class P = equal_to<K> >
+// using unordered_multimap =
+//     ::std::unordered_multimap<K, V, H, P, polymorphic_allocator<pair<const K, V>>>
+//
+// }}} // namespace std::experimental::pmr
+
+#include <experimental/unordered_map>
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <cassert>
+
+namespace pmr = std::experimental::pmr;
+
+template <class T>
+struct MyHash : std::hash<T> {};
+
+template <class T>
+struct MyPred : std::equal_to<T> {};
+
+int main()
+{
+    using K = int;
+    using V = char;
+    using DH = std::hash<K>;
+    using MH = MyHash<K>;
+    using DP = std::equal_to<K>;
+    using MP = MyPred<K>;
+    using P = std::pair<const K, V>;
+    {
+        using StdMap = std::unordered_map<K, V, DH, DP, pmr::polymorphic_allocator<P>>;
+        using PmrMap = pmr::unordered_map<K, V>;
+        static_assert(std::is_same<StdMap, PmrMap>::value, "");
+    }
+    {
+        using StdMap = std::unordered_map<K, V, MH, DP, pmr::polymorphic_allocator<P>>;
+        using PmrMap = pmr::unordered_map<K, V, MH>;
+        static_assert(std::is_same<StdMap, PmrMap>::value, "");
+    }
+    {
+        using StdMap = std::unordered_map<K, V, MH, MP, pmr::polymorphic_allocator<P>>;
+        using PmrMap = pmr::unordered_map<K, V, MH, MP>;
+        static_assert(std::is_same<StdMap, PmrMap>::value, "");
+    }
+    {
+        pmr::unordered_map<int, int> m;
+        assert(m.get_allocator().resource() == pmr::get_default_resource());
+    }
+    {
+        using StdMap = std::unordered_multimap<K, V, DH, DP, pmr::polymorphic_allocator<P>>;
+        using PmrMap = pmr::unordered_multimap<K, V>;
+        static_assert(std::is_same<StdMap, PmrMap>::value, "");
+    }
+    {
+        using StdMap = std::unordered_multimap<K, V, MH, DP, pmr::polymorphic_allocator<P>>;
+        using PmrMap = pmr::unordered_multimap<K, V, MH>;
+        static_assert(std::is_same<StdMap, PmrMap>::value, "");
+    }
+    {
+        using StdMap = std::unordered_multimap<K, V, MH, MP, pmr::polymorphic_allocator<P>>;
+        using PmrMap = pmr::unordered_multimap<K, V, MH, MP>;
+        static_assert(std::is_same<StdMap, PmrMap>::value, "");
+    }
+    {
+        pmr::unordered_multimap<int, int> m;
+        assert(m.get_allocator().resource() == pmr::get_default_resource());
+    }
+}
diff --git a/test/std/experimental/memory/memory.resource.aliases/header_unordered_set_synop.pass.cpp b/test/std/experimental/memory/memory.resource.aliases/header_unordered_set_synop.pass.cpp
new file mode 100644
index 000000000000..d427fe7c4ab0
--- /dev/null
+++ b/test/std/experimental/memory/memory.resource.aliases/header_unordered_set_synop.pass.cpp
@@ -0,0 +1,85 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++experimental
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/unordered_set>
+
+// namespace std { namespace experimental { namespace pmr {
+// template <class V, class H = hash<V>, class P = equal_to<V> >
+// using unordered_set =
+//     ::std::unordered_set<V, H, P, polymorphic_allocator<V>>
+//
+// template <class V,  class H = hash<V>, class P = equal_to<V> >
+// using unordered_multiset =
+//     ::std::unordered_multiset<V, H, P, polymorphic_allocator<V>>
+//
+// }}} // namespace std::experimental::pmr
+
+#include <experimental/unordered_set>
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <cassert>
+
+namespace pmr = std::experimental::pmr;
+
+template <class T>
+struct MyHash : std::hash<T> {};
+
+template <class T>
+struct MyPred : std::equal_to<T> {};
+
+int main()
+{
+    using V = char;
+    using DH = std::hash<V>;
+    using MH = MyHash<V>;
+    using DP = std::equal_to<V>;
+    using MP = MyPred<V>;
+    {
+        using StdSet = std::unordered_set<V, DH, DP, pmr::polymorphic_allocator<V>>;
+        using PmrSet = pmr::unordered_set<V>;
+        static_assert(std::is_same<StdSet, PmrSet>::value, "");
+    }
+    {
+        using StdSet = std::unordered_set<V, MH, DP, pmr::polymorphic_allocator<V>>;
+        using PmrSet = pmr::unordered_set<V, MH>;
+        static_assert(std::is_same<StdSet, PmrSet>::value, "");
+    }
+    {
+        using StdSet = std::unordered_set<V, MH, MP, pmr::polymorphic_allocator<V>>;
+        using PmrSet = pmr::unordered_set<V, MH, MP>;
+        static_assert(std::is_same<StdSet, PmrSet>::value, "");
+    }
+    {
+        pmr::unordered_set<int> m;
+        assert(m.get_allocator().resource() == pmr::get_default_resource());
+    }
+    {
+        using StdSet = std::unordered_multiset<V, DH, DP, pmr::polymorphic_allocator<V>>;
+        using PmrSet = pmr::unordered_multiset<V>;
+        static_assert(std::is_same<StdSet, PmrSet>::value, "");
+    }
+    {
+        using StdSet = std::unordered_multiset<V, MH, DP, pmr::polymorphic_allocator<V>>;
+        using PmrSet = pmr::unordered_multiset<V, MH>;
+        static_assert(std::is_same<StdSet, PmrSet>::value, "");
+    }
+    {
+        using StdSet = std::unordered_multiset<V, MH, MP, pmr::polymorphic_allocator<V>>;
+        using PmrSet = pmr::unordered_multiset<V, MH, MP>;
+        static_assert(std::is_same<StdSet, PmrSet>::value, "");
+    }
+    {
+        pmr::unordered_multiset<int> m;
+        assert(m.get_allocator().resource() == pmr::get_default_resource());
+    }
+}
diff --git a/test/std/experimental/memory/memory.resource.aliases/header_vector_synop.pass.cpp b/test/std/experimental/memory/memory.resource.aliases/header_vector_synop.pass.cpp
new file mode 100644
index 000000000000..7dfd3b820b36
--- /dev/null
+++ b/test/std/experimental/memory/memory.resource.aliases/header_vector_synop.pass.cpp
@@ -0,0 +1,37 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++experimental
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/vector>
+
+// namespace std { namespace experimental { namespace pmr {
+// template <class T>
+// using vector =
+//     ::std::vector<T, polymorphic_allocator<T>>
+//
+// }}} // namespace std::experimental::pmr
+
+#include <experimental/vector>
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <cassert>
+
+namespace pmr = std::experimental::pmr;
+
+int main()
+{
+    using StdVector = std::vector<int, pmr::polymorphic_allocator<int>>;
+    using PmrVector = pmr::vector<int>;
+    static_assert(std::is_same<StdVector, PmrVector>::value, "");
+    PmrVector d;
+    assert(d.get_allocator().resource() == pmr::get_default_resource());
+}
diff --git a/test/std/experimental/memory/memory.resource.global/default_resource.pass.cpp b/test/std/experimental/memory/memory.resource.global/default_resource.pass.cpp
new file mode 100644
index 000000000000..7aa16ab506fe
--- /dev/null
+++ b/test/std/experimental/memory/memory.resource.global/default_resource.pass.cpp
@@ -0,0 +1,74 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++experimental
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/memory_resource>
+
+//-----------------------------------------------------------------------------
+// TESTING memory_resource * get_default_resource() noexcept;
+//         memory_resource * set_default_resource(memory_resource*) noexcept;
+//
+// Concerns:
+//  A) 'get_default_resource()' returns a non-null memory_resource pointer.
+//  B) 'get_default_resource()' returns the value set by the last call to
+//     'set_default_resource(...)' and 'new_delete_resource()' if no call
+//     to 'set_default_resource(...)' has occurred.
+//  C) 'set_default_resource(...)' returns the previous value of the default
+//     resource.
+//  D) 'set_default_resource(T* p)' for a non-null 'p' sets the default resource
+//     to be 'p'.
+//  E) 'set_default_resource(null)' sets the default resource to
+//     'new_delete_resource()'.
+//  F) 'get_default_resource' and 'set_default_resource' are noexcept.
+
+
+#include <experimental/memory_resource>
+#include <cassert>
+
+#include "test_memory_resource.hpp"
+
+using namespace std::experimental::pmr;
+
+int main() {
+    TestResource R;
+    { // Test (A) and (B)
+        memory_resource* p = get_default_resource();
+        assert(p != nullptr);
+        assert(p == new_delete_resource());
+        assert(p == get_default_resource());
+    }
+    { // Test (C) and (D)
+        memory_resource *expect = &R;
+        memory_resource *old = set_default_resource(expect);
+        assert(old != nullptr);
+        assert(old == new_delete_resource());
+
+        memory_resource *p = get_default_resource();
+        assert(p != nullptr);
+        assert(p == expect);
+        assert(p == get_default_resource());
+    }
+    { // Test (E)
+        memory_resource* old = set_default_resource(nullptr);
+        assert(old == &R);
+        memory_resource* p = get_default_resource();
+        assert(p != nullptr);
+        assert(p == new_delete_resource());
+        assert(p == get_default_resource());
+    }
+    { // Test (F)
+        static_assert(noexcept(get_default_resource()),
+                      "get_default_resource() must be noexcept");
+
+        static_assert(noexcept(set_default_resource(nullptr)),
+                      "set_default_resource() must be noexcept");
+    }
+}
diff --git a/test/std/experimental/memory/memory.resource.global/new_delete_resource.pass.cpp b/test/std/experimental/memory/memory.resource.global/new_delete_resource.pass.cpp
new file mode 100644
index 000000000000..412e3323d1ba
--- /dev/null
+++ b/test/std/experimental/memory/memory.resource.global/new_delete_resource.pass.cpp
@@ -0,0 +1,102 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++experimental
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/memory_resource>
+
+// memory_resource * new_delete_resource()
+
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <cassert>
+
+#include "count_new.hpp"
+
+namespace ex = std::experimental::pmr;
+
+struct assert_on_compare : public ex::memory_resource
+{
+protected:
+    virtual void * do_allocate(size_t, size_t)
+    { assert(false); }
+
+    virtual void do_deallocate(void *, size_t, size_t)
+    { assert(false); }
+
+    virtual bool do_is_equal(ex::memory_resource const &) const noexcept
+    { assert(false); }
+};
+
+void test_return()
+{
+    {
+        static_assert(std::is_same<
+            decltype(ex::new_delete_resource()), ex::memory_resource*
+          >::value, "");
+    }
+    // assert not null
+    {
+        assert(ex::new_delete_resource());
+    }
+    // assert same return value
+    {
+        assert(ex::new_delete_resource() == ex::new_delete_resource());
+    }
+}
+
+void test_equality()
+{
+    // Same object
+    {
+        ex::memory_resource & r1 = *ex::new_delete_resource();
+        ex::memory_resource & r2 = *ex::new_delete_resource();
+        // check both calls returned the same object
+        assert(&r1 == &r2);
+        // check for proper equality semantics
+        assert(r1 == r2);
+        assert(r2 == r1);
+        assert(!(r1 != r2));
+        assert(!(r2 != r1));
+    }
+    // Different types
+    {
+        ex::memory_resource & r1 = *ex::new_delete_resource();
+        assert_on_compare c;
+        ex::memory_resource & r2 = c;
+        assert(r1 != r2);
+        assert(!(r1 == r2));
+    }
+}
+
+void test_allocate_deallocate()
+{
+    ex::memory_resource & r1 = *ex::new_delete_resource();
+
+    globalMemCounter.reset();
+
+    void *ret = r1.allocate(50);
+    assert(ret);
+    assert(globalMemCounter.checkOutstandingNewEq(1));
+    assert(globalMemCounter.checkLastNewSizeEq(50));
+
+    r1.deallocate(ret, 1);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
+    assert(globalMemCounter.checkDeleteCalledEq(1));
+
+}
+
+int main()
+{
+    static_assert(noexcept(ex::new_delete_resource()), "Must be noexcept");
+    test_return();
+    test_equality();
+    test_allocate_deallocate();
+}
diff --git a/test/std/experimental/memory/memory.resource.global/null_memory_resource.pass.cpp b/test/std/experimental/memory/memory.resource.global/null_memory_resource.pass.cpp
new file mode 100644
index 000000000000..f263df30ef4d
--- /dev/null
+++ b/test/std/experimental/memory/memory.resource.global/null_memory_resource.pass.cpp
@@ -0,0 +1,118 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++experimental
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/memory_resource>
+
+// memory_resource * null_memory_resource()
+
+#include <experimental/memory_resource>
+#include <new>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "count_new.hpp"
+
+namespace ex = std::experimental::pmr;
+
+struct assert_on_compare : public ex::memory_resource
+{
+protected:
+    virtual void * do_allocate(size_t, size_t)
+    { assert(false); }
+
+    virtual void do_deallocate(void *, size_t, size_t)
+    { assert(false); }
+
+    virtual bool do_is_equal(ex::memory_resource const &) const noexcept
+    { assert(false); }
+};
+
+void test_return()
+{
+    {
+        static_assert(std::is_same<
+            decltype(ex::null_memory_resource()), ex::memory_resource*
+          >::value, "");
+    }
+    // Test that the returned value is not null
+    {
+        assert(ex::null_memory_resource());
+    }
+    // Test the same value is returned by repeated calls.
+    {
+        assert(ex::null_memory_resource() == ex::null_memory_resource());
+    }
+}
+
+void test_equality()
+{
+    // Same object
+    {
+        ex::memory_resource & r1 = *ex::null_memory_resource();
+        ex::memory_resource & r2 = *ex::null_memory_resource();
+        // check both calls returned the same object
+        assert(&r1 == &r2);
+        // check for proper equality semantics
+        assert(r1 == r2);
+        assert(r2 == r1);
+        assert(!(r1 != r2));
+        assert(!(r2 != r1));
+        // check the is_equal method
+        assert(r1.is_equal(r2));
+        assert(r2.is_equal(r1));
+    }
+    // Different types
+    {
+        ex::memory_resource & r1 = *ex::null_memory_resource();
+        assert_on_compare c;
+        ex::memory_resource & r2 = c;
+        assert(r1 != r2);
+        assert(!(r1 == r2));
+        assert(!r1.is_equal(r2));
+    }
+}
+
+void test_allocate()
+{
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    DisableAllocationGuard g; // null_memory_resource shouldn't allocate.
+    try {
+        ex::null_memory_resource()->allocate(1);
+        assert(false);
+    } catch (std::bad_alloc const &) {
+       // do nothing
+    } catch (...) {
+        assert(false);
+    }
+#endif
+}
+
+void test_deallocate()
+{
+    globalMemCounter.reset();
+
+    int x = 42;
+    ex::null_memory_resource()->deallocate(nullptr, 0);
+    ex::null_memory_resource()->deallocate(&x, 0);
+
+    assert(globalMemCounter.checkDeleteCalledEq(0));
+    assert(globalMemCounter.checkDeleteArrayCalledEq(0));
+}
+
+int main()
+{
+    test_return();
+    test_equality();
+    test_allocate();
+    test_deallocate();
+}
diff --git a/test/std/experimental/memory/memory.resource.synop/nothing_to_do.pass.cpp b/test/std/experimental/memory/memory.resource.synop/nothing_to_do.pass.cpp
new file mode 100644
index 000000000000..9a59227abdd9
--- /dev/null
+++ b/test/std/experimental/memory/memory.resource.synop/nothing_to_do.pass.cpp
@@ -0,0 +1,13 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+int main()
+{
+}
diff --git a/test/std/experimental/memory/memory.resource/construct.fail.cpp b/test/std/experimental/memory/memory.resource/construct.fail.cpp
new file mode 100644
index 000000000000..d990714acfd1
--- /dev/null
+++ b/test/std/experimental/memory/memory.resource/construct.fail.cpp
@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/memory_resource>
+
+// Check that memory_resource is not constructible
+
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <cassert>
+
+namespace ex = std::experimental::pmr;
+
+int main()
+{
+    ex::memory_resource m; // expected-error {{variable type 'ex::memory_resource' is an abstract class}}
+}
diff --git a/test/std/experimental/memory/memory.resource/memory.resource.eq/equal.pass.cpp b/test/std/experimental/memory/memory.resource/memory.resource.eq/equal.pass.cpp
new file mode 100644
index 000000000000..0ccdeed3c54f
--- /dev/null
+++ b/test/std/experimental/memory/memory.resource/memory.resource.eq/equal.pass.cpp
@@ -0,0 +1,76 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/memory_resource>
+
+// bool operator==(memory_resource const &, memory_resource const &) noexcept;
+
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_memory_resource.hpp"
+
+namespace ex = std::experimental::pmr;
+
+int main()
+{
+    // check return types
+    {
+        ex::memory_resource const * mr1(nullptr);
+        ex::memory_resource const * mr2(nullptr);
+        static_assert(std::is_same<decltype(*mr1 == *mr2), bool>::value, "");
+        static_assert(noexcept(*mr1 == *mr2), "");
+    }
+    // equal
+    {
+        TestResource r1(1);
+        TestResource r2(1);
+        ex::memory_resource const & mr1 = r1;
+        ex::memory_resource const & mr2 = r2;
+
+        assert(mr1 == mr2);
+        assert(r1.checkIsEqualCalledEq(1));
+        assert(r2.checkIsEqualCalledEq(0));
+
+        assert(mr2 == mr1);
+        assert(r1.checkIsEqualCalledEq(1));
+        assert(r2.checkIsEqualCalledEq(1));
+    }
+    // equal same object
+    {
+        TestResource r1(1);
+        ex::memory_resource const & mr1 = r1;
+        ex::memory_resource const & mr2 = r1;
+
+        assert(mr1 == mr2);
+        assert(r1.checkIsEqualCalledEq(0));
+
+        assert(mr2 == mr1);
+        assert(r1.checkIsEqualCalledEq(0));
+    }
+    // not equal
+    {
+        TestResource r1(1);
+        TestResource r2(2);
+        ex::memory_resource const & mr1 = r1;
+        ex::memory_resource const & mr2 = r2;
+
+        assert(!(mr1 == mr2));
+        assert(r1.checkIsEqualCalledEq(1));
+        assert(r2.checkIsEqualCalledEq(0));
+
+        assert(!(mr2 == mr1));
+        assert(r1.checkIsEqualCalledEq(1));
+        assert(r2.checkIsEqualCalledEq(1));
+    }
+}
diff --git a/test/std/experimental/memory/memory.resource/memory.resource.eq/not_equal.pass.cpp b/test/std/experimental/memory/memory.resource/memory.resource.eq/not_equal.pass.cpp
new file mode 100644
index 000000000000..ede1bfdf9bac
--- /dev/null
+++ b/test/std/experimental/memory/memory.resource/memory.resource.eq/not_equal.pass.cpp
@@ -0,0 +1,75 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/memory_resource>
+
+// bool operator!=(memory_resource const &, memory_resource const &) noexcept;
+
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <cassert>
+
+#include "test_memory_resource.hpp"
+
+namespace ex = std::experimental::pmr;
+
+int main()
+{
+    // check return types
+    {
+        ex::memory_resource const * mr1(nullptr);
+        ex::memory_resource const * mr2(nullptr);
+        static_assert(std::is_same<decltype(*mr1 != *mr2), bool>::value, "");
+        static_assert(noexcept(*mr1 != *mr2), "");
+    }
+    // not equal
+    {
+        TestResource r1(1);
+        TestResource r2(2);
+        ex::memory_resource const & mr1 = r1;
+        ex::memory_resource const & mr2 = r2;
+
+        assert(mr1 != mr2);
+        assert(r1.checkIsEqualCalledEq(1));
+        assert(r2.checkIsEqualCalledEq(0));
+
+        assert(mr2 != mr1);
+        assert(r1.checkIsEqualCalledEq(1));
+        assert(r2.checkIsEqualCalledEq(1));
+    }
+    // equal
+    {
+        TestResource r1(1);
+        TestResource r2(1);
+        ex::memory_resource const & mr1 = r1;
+        ex::memory_resource const & mr2 = r2;
+
+        assert(!(mr1 != mr2));
+        assert(r1.checkIsEqualCalledEq(1));
+        assert(r2.checkIsEqualCalledEq(0));
+
+        assert(!(mr2 != mr1));
+        assert(r1.checkIsEqualCalledEq(1));
+        assert(r2.checkIsEqualCalledEq(1));
+    }
+    // equal same object
+    {
+        TestResource r1(1);
+        ex::memory_resource const & mr1 = r1;
+        ex::memory_resource const & mr2 = r1;
+
+        assert(!(mr1 != mr2));
+        assert(r1.checkIsEqualCalledEq(0));
+
+        assert(!(mr2 != mr1));
+        assert(r1.checkIsEqualCalledEq(0));
+    }
+}
diff --git a/test/std/experimental/memory/memory.resource/memory.resource.overview/nothing_to_do.pass.cpp b/test/std/experimental/memory/memory.resource/memory.resource.overview/nothing_to_do.pass.cpp
new file mode 100644
index 000000000000..86bf8cc11bb9
--- /dev/null
+++ b/test/std/experimental/memory/memory.resource/memory.resource.overview/nothing_to_do.pass.cpp
@@ -0,0 +1,10 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+int main () {}
diff --git a/test/std/experimental/memory/memory.resource/memory.resource.priv/protected_members.fail.cpp b/test/std/experimental/memory/memory.resource/memory.resource.priv/protected_members.fail.cpp
new file mode 100644
index 000000000000..eddfede29630
--- /dev/null
+++ b/test/std/experimental/memory/memory.resource/memory.resource.priv/protected_members.fail.cpp
@@ -0,0 +1,27 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/memory_resource>
+
+// memory_resource::do_allocate(size_t, size_t);          /* protected */
+// memory_resource::do_deallocate(void*, size_t, size_t); /* protected */
+// memory_resource::do_is_equal(memory_resource const&);  /* protected */
+
+#include <experimental/memory_resource>
+
+namespace ex = std::experimental::pmr;
+
+int main() {
+    ex::memory_resource *m = ex::new_delete_resource();
+    m->do_allocate(0, 0); // expected-error{{'do_allocate' is a protected member}}
+    m->do_deallocate(nullptr, 0, 0); // expected-error{{'do_deallocate' is a protected member}}
+    m->do_is_equal(*m); // expected-error{{'do_is_equal' is a protected member}}
+}
\ No newline at end of file
diff --git a/test/std/experimental/memory/memory.resource/memory.resource.public/allocate.pass.cpp b/test/std/experimental/memory/memory.resource/memory.resource.public/allocate.pass.cpp
new file mode 100644
index 000000000000..26cf903fe0d8
--- /dev/null
+++ b/test/std/experimental/memory/memory.resource/memory.resource.public/allocate.pass.cpp
@@ -0,0 +1,89 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <experimental/memory_resource>
+
+// UNSUPPORTED: c++98, c++03
+
+//------------------------------------------------------------------------------
+// TESTING void * memory_resource::allocate(size_t, size_t = max_align)
+//
+// Concerns:
+//  A) 'memory_resource' contains a member 'allocate' with the required
+//     signature, including the default alignment parameter.
+//  B) The return type of 'allocate' is 'void*'.
+//  C) 'allocate' is not marked as 'noexcept'.
+//  D) Invoking 'allocate' invokes 'do_allocate' with the same arguments.
+//  E) If 'do_allocate' throws then 'allocate' propagates that exception.
+
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <cstddef>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_memory_resource.hpp"
+
+using std::experimental::pmr::memory_resource;
+
+int main()
+{
+    TestResource R(42);
+    auto& P = R.getController();
+    memory_resource& M = R;
+    {
+        static_assert(
+            std::is_same<decltype(M.allocate(0, 0)), void*>::value
+          , "Must be void*"
+          );
+        static_assert(
+            std::is_same<decltype(M.allocate(0)), void*>::value
+          , "Must be void*"
+          );
+    }
+    {
+        static_assert(
+            ! noexcept(M.allocate(0, 0))
+          , "Must not be noexcept."
+          );
+        static_assert(
+            ! noexcept(M.allocate(0))
+          , "Must not be noexcept."
+          );
+    }
+    {
+        int s = 42;
+        int a = 64;
+        void* p = M.allocate(s, a);
+        assert(P.alloc_count == 1);
+        assert(P.checkAlloc(p, s, a));
+
+        s = 128;
+        a = MaxAlignV;
+        p = M.allocate(s);
+        assert(P.alloc_count == 2);
+        assert(P.checkAlloc(p, s, a));
+    }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    {
+        TestResource R2;
+        auto& P = R2.getController();
+        P.throw_on_alloc = true;
+        memory_resource& M2 = R2;
+        try {
+            M2.allocate(42);
+            assert(false);
+        } catch (TestException const&) {
+            // do nothing.
+        } catch (...) {
+            assert(false);
+        }
+    }
+#endif
+}
diff --git a/test/std/experimental/memory/memory.resource/memory.resource.public/deallocate.pass.cpp b/test/std/experimental/memory/memory.resource/memory.resource.public/deallocate.pass.cpp
new file mode 100644
index 000000000000..d1a4ab2b8196
--- /dev/null
+++ b/test/std/experimental/memory/memory.resource/memory.resource.public/deallocate.pass.cpp
@@ -0,0 +1,74 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <experimental/memory_resource>
+
+// UNSUPPORTED: c++98, c++03
+
+//------------------------------------------------------------------------------
+// TESTING void * memory_resource::deallocate(void *, size_t, size_t = max_align)
+//
+// Concerns:
+//  A) 'memory_resource' contains a member 'deallocate' with the required
+//     signature, including the default alignment parameter.
+//  B) The return type of 'deallocate' is 'void'.
+//  C) 'deallocate' is not marked as 'noexcept'.
+//  D) Invoking 'deallocate' invokes 'do_deallocate' with the same arguments.
+
+
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <cstddef>
+#include <cassert>
+
+#include "test_memory_resource.hpp"
+
+using std::experimental::pmr::memory_resource;
+
+int main()
+{
+    NullResource R(42);
+    auto& P = R.getController();
+    memory_resource& M = R;
+    {
+        static_assert(
+            std::is_same<decltype(M.deallocate(nullptr, 0, 0)), void>::value
+          , "Must be void"
+          );
+        static_assert(
+            std::is_same<decltype(M.deallocate(nullptr, 0)), void>::value
+          , "Must be void"
+          );
+    }
+    {
+        static_assert(
+            ! noexcept(M.deallocate(nullptr, 0, 0))
+          , "Must not be noexcept."
+          );
+        static_assert(
+            ! noexcept(M.deallocate(nullptr, 0))
+          , "Must not be noexcept."
+          );
+    }
+    {
+        int s = 100;
+        int a = 64;
+        void* p = reinterpret_cast<void*>(640);
+        M.deallocate(p, s, a);
+        assert(P.dealloc_count == 1);
+        assert(P.checkDealloc(p, s, a));
+
+        s = 128;
+        a = alignof(std::max_align_t);
+        p = reinterpret_cast<void*>(12800);
+        M.deallocate(p, s);
+        assert(P.dealloc_count == 2);
+        assert(P.checkDealloc(p, s, a));
+    }
+}
diff --git a/test/std/experimental/memory/memory.resource/memory.resource.public/dtor.pass.cpp b/test/std/experimental/memory/memory.resource/memory.resource.public/dtor.pass.cpp
new file mode 100644
index 000000000000..9e1d28618f92
--- /dev/null
+++ b/test/std/experimental/memory/memory.resource/memory.resource.public/dtor.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
+
+// <experimental/memory_resource>
+
+//------------------------------------------------------------------------------
+// TESTING virtual ~memory_resource()
+//
+// Concerns:
+//  A) 'memory_resource' is destructible.
+//  B) The destructor is implicitly marked noexcept.
+//  C) The destructor is marked virtual.
+
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <cassert>
+
+#include "test_memory_resource.hpp"
+
+using std::experimental::pmr::memory_resource;
+
+int main()
+{
+    static_assert(
+        std::has_virtual_destructor<memory_resource>::value
+      , "Must have virtual destructor"
+      );
+    static_assert(
+        std::is_nothrow_destructible<memory_resource>::value,
+        "Must be nothrow destructible"
+      );
+    static_assert(
+        std::is_abstract<memory_resource>::value
+      , "Must be abstract"
+      );
+    // Check that the destructor of `TestResource` is called when
+    // it is deleted as a pointer to `memory_resource`
+    {
+        using TR = TestResource;
+        memory_resource* M = new TR(42);
+        assert(TR::resource_alive == 1);
+        assert(TR::resource_constructed == 1);
+        assert(TR::resource_destructed == 0);
+
+        delete M;
+
+        assert(TR::resource_alive == 0);
+        assert(TR::resource_constructed == 1);
+        assert(TR::resource_destructed == 1);
+    }
+}
diff --git a/test/std/experimental/memory/memory.resource/memory.resource.public/is_equal.pass.cpp b/test/std/experimental/memory/memory.resource/memory.resource.public/is_equal.pass.cpp
new file mode 100644
index 000000000000..32792cf867a6
--- /dev/null
+++ b/test/std/experimental/memory/memory.resource/memory.resource.public/is_equal.pass.cpp
@@ -0,0 +1,93 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <experimental/memory_resource>
+
+//------------------------------------------------------------------------------
+// TESTING virtual bool is_equal(memory_resource const &) const noexcept
+//
+// Concerns:
+//   A) 'memory_resource' provides a function 'is_equal' with the required
+//      signature.
+//   B) 'is_equal' is noexcept.
+//   C) 'do_is_equal' is called using the same arguments passed to 'is_equal'
+//      and the resulting value is returned.
+//   D) 'do_is_equal' is called on the LHS object and not the RHS object.
+
+#include <experimental/memory_resource>
+#include <type_traits>
+#include <cassert>
+#include "test_memory_resource.hpp"
+
+using std::experimental::pmr::memory_resource;
+
+int main()
+{
+    {
+        memory_resource const* r1 = nullptr;
+        memory_resource const* r2 = nullptr;
+        static_assert(
+            noexcept(r1->is_equal(*r2))
+          , "is_equal must be noexcept"
+          );
+    }
+    {
+        TestResource1 R1(1);
+        auto& P1 = R1.getController();
+        memory_resource const& M1 = R1;
+
+        TestResource2 R2(1);
+        auto& P2 = R2.getController();
+        memory_resource const& M2 = R2;
+
+        assert(M1.is_equal(M2) == false);
+        assert(P1.checkIsEqualCalledEq(1));
+        assert(P2.checkIsEqualCalledEq(0));
+
+        assert(M2.is_equal(M1) == false);
+        assert(P2.checkIsEqualCalledEq(1));
+        assert(P1.checkIsEqualCalledEq(1));
+    }
+    {
+        TestResource1 R1(1);
+        auto& P1 = R1.getController();
+        memory_resource const& M1 = R1;
+
+        TestResource1 R2(2);
+        auto& P2 = R2.getController();
+        memory_resource const& M2 = R2;
+
+        assert(M1.is_equal(M2) == false);
+        assert(P1.checkIsEqualCalledEq(1));
+        assert(P2.checkIsEqualCalledEq(0));
+
+        assert(M2.is_equal(M1) == false);
+        assert(P2.checkIsEqualCalledEq(1));
+        assert(P1.checkIsEqualCalledEq(1));
+    }
+    {
+        TestResource1 R1(1);
+        auto& P1 = R1.getController();
+        memory_resource const& M1 = R1;
+
+        TestResource1 R2(1);
+        auto& P2 = R2.getController();
+        memory_resource const& M2 = R2;
+
+        assert(M1.is_equal(M2) == true);
+        assert(P1.checkIsEqualCalledEq(1));
+        assert(P2.checkIsEqualCalledEq(0));
+
+        assert(M2.is_equal(M1) == true);
+        assert(P2.checkIsEqualCalledEq(1));
+        assert(P1.checkIsEqualCalledEq(1));
+    }
+}
diff --git a/test/std/experimental/memory/nothing_to_do.pass.cpp b/test/std/experimental/memory/nothing_to_do.pass.cpp
new file mode 100644
index 000000000000..9a59227abdd9
--- /dev/null
+++ b/test/std/experimental/memory/nothing_to_do.pass.cpp
@@ -0,0 +1,13 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+int main()
+{
+}
diff --git a/test/std/experimental/optional/optional.bad_optional_access/default.pass.cpp b/test/std/experimental/optional/optional.bad_optional_access/default.pass.cpp
index cecf98a3518b..c166bb72a837 100644
--- a/test/std/experimental/optional/optional.bad_optional_access/default.pass.cpp
+++ b/test/std/experimental/optional/optional.bad_optional_access/default.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
+
 // <optional>
 
 // class bad_optional_access is default constructible
@@ -16,8 +18,6 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     using std::experimental::bad_optional_access;
     bad_optional_access ex;
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.bad_optional_access/derive.pass.cpp b/test/std/experimental/optional/optional.bad_optional_access/derive.pass.cpp
index c13d6603990a..4630165f0708 100644
--- a/test/std/experimental/optional/optional.bad_optional_access/derive.pass.cpp
+++ b/test/std/experimental/optional/optional.bad_optional_access/derive.pass.cpp
@@ -7,19 +7,19 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
+
 // <optional>
 
-// class bad_optional_access : public logic_error 
+// class bad_optional_access : public logic_error
 
 #include <experimental/optional>
 #include <type_traits>
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     using std::experimental::bad_optional_access;
 
     static_assert(std::is_base_of<std::logic_error, bad_optional_access>::value, "");
     static_assert(std::is_convertible<bad_optional_access*, std::logic_error*>::value, "");
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.comp_with_t/equal.pass.cpp b/test/std/experimental/optional/optional.comp_with_t/equal.pass.cpp
index e796723cc097..749fa7dcf0a1 100644
--- a/test/std/experimental/optional/optional.comp_with_t/equal.pass.cpp
+++ b/test/std/experimental/optional/optional.comp_with_t/equal.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // template <class T> constexpr bool operator==(const optional<T>& x, const T& v);
@@ -14,8 +15,6 @@
 
 #include <experimental/optional>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 
 struct X
@@ -27,16 +26,13 @@ struct X
 
 constexpr bool operator == ( const X &lhs, const X &rhs )
     { return lhs.i_ == rhs.i_ ; }
-    
-#endif
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     {
     typedef X T;
     typedef optional<T> O;
-    
+
     constexpr T val(2);
     constexpr O o1;       // disengaged
     constexpr O o2{1};    // engaged
@@ -47,12 +43,11 @@ int main()
     static_assert ( !(o3 == T(1)), "" );
     static_assert (  (o3 == T(2)), "" );
     static_assert (  (o3 == val),  "" );
-        
+
     static_assert ( !(T(1) == o1), "" );
     static_assert (  (T(1) == o2), "" );
     static_assert ( !(T(1) == o3), "" );
     static_assert (  (T(2) == o3), "" );
     static_assert (  (val  == o3), "" );
     }
-#endif
 }
diff --git a/test/std/experimental/optional/optional.comp_with_t/greater.pass.cpp b/test/std/experimental/optional/optional.comp_with_t/greater.pass.cpp
index cf3923bb4fb0..c4d95a1c878f 100644
--- a/test/std/experimental/optional/optional.comp_with_t/greater.pass.cpp
+++ b/test/std/experimental/optional/optional.comp_with_t/greater.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // template <class T> constexpr bool operator>(const optional<T>& x, const T& v);
@@ -14,8 +15,6 @@
 
 #include <experimental/optional>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 
 struct X
@@ -27,13 +26,9 @@ struct X
 
 constexpr bool operator < ( const X &lhs, const X &rhs )
     { return lhs.i_ < rhs.i_ ; }
-    
-#endif
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
-
     {
     typedef X T;
     typedef optional<T> O;
@@ -57,5 +52,4 @@ int main()
     static_assert (  !(val  > o3), "" ); // equal
     static_assert (   (T(3) > o3), "" );
     }
-#endif
 }
diff --git a/test/std/experimental/optional/optional.comp_with_t/greater_equal.pass.cpp b/test/std/experimental/optional/optional.comp_with_t/greater_equal.pass.cpp
index 85fea1377b3c..ce1cd9f98481 100644
--- a/test/std/experimental/optional/optional.comp_with_t/greater_equal.pass.cpp
+++ b/test/std/experimental/optional/optional.comp_with_t/greater_equal.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // template <class T> constexpr bool operator>=(const optional<T>& x, const T& v);
@@ -14,8 +15,6 @@
 
 #include <experimental/optional>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 
 struct X
@@ -27,13 +26,9 @@ struct X
 
 constexpr bool operator < ( const X &lhs, const X &rhs )
     { return lhs.i_ < rhs.i_ ; }
-    
-#endif
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
-
     {
     typedef X T;
     typedef optional<T> O;
@@ -57,5 +52,4 @@ int main()
     static_assert (   (val  >= o3), "" ); // equal
     static_assert (   (T(3) >= o3), "" );
     }
-#endif
 }
diff --git a/test/std/experimental/optional/optional.comp_with_t/less_equal.pass.cpp b/test/std/experimental/optional/optional.comp_with_t/less_equal.pass.cpp
index 333f7cdea219..c519bde1e9f2 100644
--- a/test/std/experimental/optional/optional.comp_with_t/less_equal.pass.cpp
+++ b/test/std/experimental/optional/optional.comp_with_t/less_equal.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // template <class T> constexpr bool operator<=(const optional<T>& x, const T& v);
@@ -14,8 +15,6 @@
 
 #include <experimental/optional>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 
 struct X
@@ -27,13 +26,9 @@ struct X
 
 constexpr bool operator < ( const X &lhs, const X &rhs )
     { return lhs.i_ < rhs.i_ ; }
-    
-#endif
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
-
     {
     typedef X T;
     typedef optional<T> O;
@@ -57,5 +52,4 @@ int main()
     static_assert (   (val  <= o3), "" ); // equal
     static_assert (  !(T(3) <= o3), "" );
     }
-#endif
 }
diff --git a/test/std/experimental/optional/optional.comp_with_t/less_than.pass.cpp b/test/std/experimental/optional/optional.comp_with_t/less_than.pass.cpp
index e35df21bbabb..ee1e98f2b8c9 100644
--- a/test/std/experimental/optional/optional.comp_with_t/less_than.pass.cpp
+++ b/test/std/experimental/optional/optional.comp_with_t/less_than.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // template <class T> constexpr bool operator<(const optional<T>& x, const T& v);
@@ -14,8 +15,6 @@
 
 #include <experimental/optional>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 
 struct X
@@ -27,13 +26,9 @@ struct X
 
 constexpr bool operator < ( const X &lhs, const X &rhs )
     { return lhs.i_ < rhs.i_ ; }
-    
-#endif
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
-
     {
     typedef X T;
     typedef optional<T> O;
@@ -57,5 +52,4 @@ int main()
     static_assert (  !(val  < o3), "" ); // equal
     static_assert (  !(T(3) < o3), "" );
     }
-#endif
 }
diff --git a/test/std/experimental/optional/optional.comp_with_t/not_equal.pass.cpp b/test/std/experimental/optional/optional.comp_with_t/not_equal.pass.cpp
index 0dad68d38635..a3daa02d5dbb 100644
--- a/test/std/experimental/optional/optional.comp_with_t/not_equal.pass.cpp
+++ b/test/std/experimental/optional/optional.comp_with_t/not_equal.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // template <class T> constexpr bool operator!=(const optional<T>& x, const T& v);
@@ -14,8 +15,6 @@
 
 #include <experimental/optional>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 
 struct X
@@ -27,16 +26,13 @@ struct X
 
 constexpr bool operator == ( const X &lhs, const X &rhs )
     { return lhs.i_ == rhs.i_ ; }
-    
-#endif
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     {
     typedef X T;
     typedef optional<T> O;
-    
+
     constexpr T val(2);
     constexpr O o1;       // disengaged
     constexpr O o2{1};    // engaged
@@ -47,12 +43,11 @@ int main()
     static_assert (  (o3 != T(1)), "" );
     static_assert ( !(o3 != T(2)), "" );
     static_assert ( !(o3 != val),  "" );
-        
+
     static_assert (  (T(1) != o1), "" );
     static_assert ( !(T(1) != o2), "" );
     static_assert (  (T(1) != o3), "" );
     static_assert ( !(T(2) != o3), "" );
     static_assert ( !(val  != o3), "" );
     }
-#endif
 }
diff --git a/test/std/experimental/optional/optional.hash/hash.pass.cpp b/test/std/experimental/optional/optional.hash/hash.pass.cpp
index 9e5fb55c833f..21126740bf86 100644
--- a/test/std/experimental/optional/optional.hash/hash.pass.cpp
+++ b/test/std/experimental/optional/optional.hash/hash.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // template <class T> struct hash<optional<T>>;
@@ -19,7 +20,6 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     using std::experimental::optional;
 
     {
@@ -43,5 +43,4 @@ int main()
         opt = std::unique_ptr<int>(new int(3));
         assert(std::hash<optional<T>>{}(opt) == std::hash<T>{}(*opt));
     }
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.inplace/in_place_t.pass.cpp b/test/std/experimental/optional/optional.inplace/in_place_t.pass.cpp
index 360b9d91671e..b63977bb69ff 100644
--- a/test/std/experimental/optional/optional.inplace/in_place_t.pass.cpp
+++ b/test/std/experimental/optional/optional.inplace/in_place_t.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // struct in_place_t{};
@@ -15,8 +16,6 @@
 #include <experimental/optional>
 #include <type_traits>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 using std::experimental::in_place_t;
 using std::experimental::in_place;
@@ -28,15 +27,10 @@ test(const in_place_t&)
     return 3;
 }
 
-#endif
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
-
     static_assert((std::is_class<in_place_t>::value), "");
     static_assert((std::is_empty<in_place_t>::value), "");
-    
+
     static_assert(test(in_place) == 3, "");
-#endif
 }
diff --git a/test/std/experimental/optional/optional.nullops/equal.pass.cpp b/test/std/experimental/optional/optional.nullops/equal.pass.cpp
index 931db6144256..79a5a7e06fa4 100644
--- a/test/std/experimental/optional/optional.nullops/equal.pass.cpp
+++ b/test/std/experimental/optional/optional.nullops/equal.pass.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // template <class T> constexpr bool operator==(const optional<T>& x, nullopt_t) noexcept;
@@ -17,15 +17,14 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     using std::experimental::optional;
     using std::experimental::nullopt_t;
     using std::experimental::nullopt;
-    
+
     {
     typedef int T;
     typedef optional<T> O;
-    
+
     constexpr O o1;     // disengaged
     constexpr O o2{1};  // engaged
 
@@ -37,5 +36,4 @@ int main()
     static_assert (noexcept(nullopt == o1), "");
     static_assert (noexcept(o1 == nullopt), "");
     }
-#endif
 }
diff --git a/test/std/experimental/optional/optional.nullops/greater.pass.cpp b/test/std/experimental/optional/optional.nullops/greater.pass.cpp
index b72a4d3f1a6a..15b22005b830 100644
--- a/test/std/experimental/optional/optional.nullops/greater.pass.cpp
+++ b/test/std/experimental/optional/optional.nullops/greater.pass.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // template <class T> constexpr bool operator>(const optional<T>& x, nullopt_t) noexcept;
@@ -17,7 +17,6 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     using std::experimental::optional;
     using std::experimental::nullopt_t;
     using std::experimental::nullopt;
@@ -25,7 +24,7 @@ int main()
     {
     typedef int T;
     typedef optional<T> O;
-    
+
     constexpr O o1;     // disengaged
     constexpr O o2{1};  // engaged
 
@@ -37,5 +36,4 @@ int main()
     static_assert (noexcept(nullopt > o1), "");
     static_assert (noexcept(o1 > nullopt), "");
     }
-#endif
 }
diff --git a/test/std/experimental/optional/optional.nullops/greater_equal.pass.cpp b/test/std/experimental/optional/optional.nullops/greater_equal.pass.cpp
index 86c8743b5558..313770ff408e 100644
--- a/test/std/experimental/optional/optional.nullops/greater_equal.pass.cpp
+++ b/test/std/experimental/optional/optional.nullops/greater_equal.pass.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // template <class T> constexpr bool operator>=(const optional<T>& x, nullopt_t) noexcept;
@@ -17,7 +17,6 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     using std::experimental::optional;
     using std::experimental::nullopt_t;
     using std::experimental::nullopt;
@@ -25,7 +24,7 @@ int main()
     {
     typedef int T;
     typedef optional<T> O;
-    
+
     constexpr O o1;     // disengaged
     constexpr O o2{1};  // engaged
 
@@ -37,5 +36,4 @@ int main()
     static_assert (noexcept(nullopt >= o1), "");
     static_assert (noexcept(o1 >= nullopt), "");
     }
-#endif
 }
diff --git a/test/std/experimental/optional/optional.nullops/less_equal.pass.cpp b/test/std/experimental/optional/optional.nullops/less_equal.pass.cpp
index 3e8444bc73f0..cddb27e93a6a 100644
--- a/test/std/experimental/optional/optional.nullops/less_equal.pass.cpp
+++ b/test/std/experimental/optional/optional.nullops/less_equal.pass.cpp
@@ -25,7 +25,7 @@ int main()
     {
     typedef int T;
     typedef optional<T> O;
-    
+
     constexpr O o1;     // disengaged
     constexpr O o2{1};  // engaged
 
diff --git a/test/std/experimental/optional/optional.nullops/less_than.pass.cpp b/test/std/experimental/optional/optional.nullops/less_than.pass.cpp
index 149c809b0403..fdb400700d83 100644
--- a/test/std/experimental/optional/optional.nullops/less_than.pass.cpp
+++ b/test/std/experimental/optional/optional.nullops/less_than.pass.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // template <class T> constexpr bool operator<(const optional<T>& x, nullopt_t) noexcept;
@@ -17,7 +17,6 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     using std::experimental::optional;
     using std::experimental::nullopt_t;
     using std::experimental::nullopt;
@@ -25,7 +24,7 @@ int main()
     {
     typedef int T;
     typedef optional<T> O;
-    
+
     constexpr O o1;     // disengaged
     constexpr O o2{1};  // engaged
 
@@ -37,5 +36,4 @@ int main()
     static_assert (noexcept(nullopt < o1), "");
     static_assert (noexcept(o1 < nullopt), "");
     }
-#endif
 }
diff --git a/test/std/experimental/optional/optional.nullops/not_equal.pass.cpp b/test/std/experimental/optional/optional.nullops/not_equal.pass.cpp
index 6f28edf6d266..70ae0f1d885c 100644
--- a/test/std/experimental/optional/optional.nullops/not_equal.pass.cpp
+++ b/test/std/experimental/optional/optional.nullops/not_equal.pass.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // template <class T> constexpr bool operator!=(const optional<T>& x, nullopt_t) noexcept;
@@ -17,15 +17,14 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     using std::experimental::optional;
     using std::experimental::nullopt_t;
     using std::experimental::nullopt;
-    
+
     {
     typedef int T;
     typedef optional<T> O;
-    
+
     constexpr O o1;     // disengaged
     constexpr O o2{1};  // engaged
 
@@ -37,5 +36,4 @@ int main()
     static_assert (noexcept(nullopt != o1), "");
     static_assert (noexcept(o1 != nullopt), "");
     }
-#endif
 }
diff --git a/test/std/experimental/optional/optional.nullopt/nullopt_t.pass.cpp b/test/std/experimental/optional/optional.nullopt/nullopt_t.pass.cpp
index de1e83b653ce..8ad49c7485d0 100644
--- a/test/std/experimental/optional/optional.nullopt/nullopt_t.pass.cpp
+++ b/test/std/experimental/optional/optional.nullopt/nullopt_t.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // struct nullopt_t{see below};
@@ -15,8 +16,6 @@
 #include <experimental/optional>
 #include <type_traits>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 using std::experimental::nullopt_t;
 using std::experimental::nullopt;
@@ -28,16 +27,12 @@ test(const nullopt_t&)
     return 3;
 }
 
-#endif
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     static_assert((std::is_class<nullopt_t>::value), "");
     static_assert((std::is_empty<nullopt_t>::value), "");
     static_assert((std::is_literal_type<nullopt_t>::value), "");
     static_assert((!std::is_default_constructible<nullopt_t>::value), "");
-    
+
     static_assert(test(nullopt) == 3, "");
-#endif
 }
diff --git a/test/std/experimental/optional/optional.object/optional.object.assign/assign_value.pass.cpp b/test/std/experimental/optional/optional.object/optional.object.assign/assign_value.pass.cpp
index e256a098f1ac..3d0d2e03158b 100644
--- a/test/std/experimental/optional/optional.object/optional.object.assign/assign_value.pass.cpp
+++ b/test/std/experimental/optional/optional.object/optional.object.assign/assign_value.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // template <class U> optional<T>& operator=(U&& v);
@@ -16,19 +17,14 @@
 #include <cassert>
 #include <memory>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 
 struct X
 {
 };
 
-#endif  // _LIBCPP_STD_VER > 11
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     static_assert(std::is_assignable<optional<int>, int>::value, "");
     static_assert(std::is_assignable<optional<int>, int&>::value, "");
     static_assert(std::is_assignable<optional<int>&, int>::value, "");
@@ -68,5 +64,4 @@ int main()
         assert(static_cast<bool>(opt) == true);
         assert(**opt == 3);
     }
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.object/optional.object.assign/copy.pass.cpp b/test/std/experimental/optional/optional.object/optional.object.assign/copy.pass.cpp
index 999d03d3a885..89ea345029c2 100644
--- a/test/std/experimental/optional/optional.object/optional.object.assign/copy.pass.cpp
+++ b/test/std/experimental/optional/optional.object/optional.object.assign/copy.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // XFAIL: libcpp-no-exceptions
 // <optional>
 
@@ -16,8 +17,6 @@
 #include <type_traits>
 #include <cassert>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 
 struct X
@@ -34,11 +33,8 @@ struct X
 
 bool X::throw_now = false;
 
-#endif  // _LIBCPP_STD_VER > 11
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     {
         optional<int> opt;
         constexpr optional<int> opt2;
@@ -87,5 +83,4 @@ int main()
             assert(static_cast<bool>(opt) == false);
         }
     }
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.object/optional.object.assign/emplace.pass.cpp b/test/std/experimental/optional/optional.object/optional.object.assign/emplace.pass.cpp
index ec98ef449153..94f2bb21a475 100644
--- a/test/std/experimental/optional/optional.object/optional.object.assign/emplace.pass.cpp
+++ b/test/std/experimental/optional/optional.object/optional.object.assign/emplace.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // XFAIL: libcpp-no-exceptions
 // <optional>
 
@@ -17,8 +18,6 @@
 #include <cassert>
 #include <memory>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 
 class X
@@ -55,11 +54,8 @@ public:
 
 bool Z::dtor_called = false;
 
-#endif  // _LIBCPP_STD_VER > 11
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     {
         optional<int> opt;
         opt.emplace();
@@ -145,5 +141,4 @@ int main()
             assert(Z::dtor_called == true);
         }
     }
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.object/optional.object.assign/emplace_initializer_list.pass.cpp b/test/std/experimental/optional/optional.object/optional.object.assign/emplace_initializer_list.pass.cpp
index aada0f4ec535..fec37408e43b 100644
--- a/test/std/experimental/optional/optional.object/optional.object.assign/emplace_initializer_list.pass.cpp
+++ b/test/std/experimental/optional/optional.object/optional.object.assign/emplace_initializer_list.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // XFAIL: libcpp-no-exceptions
 // <optional>
 
@@ -18,8 +19,6 @@
 #include <cassert>
 #include <vector>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 
 class X
@@ -60,7 +59,7 @@ public:
     static bool dtor_called;
     constexpr Z() : i_(0) {}
     constexpr Z(int i) : i_(i) {}
-    constexpr Z(std::initializer_list<int> il) : i_(il.begin()[0]), j_(il.begin()[1])
+    Z(std::initializer_list<int> il) : i_(il.begin()[0]), j_(il.begin()[1])
         {throw 6;}
     ~Z() {dtor_called = true;}
 
@@ -70,11 +69,8 @@ public:
 
 bool Z::dtor_called = false;
 
-#endif  // _LIBCPP_STD_VER > 11
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     {
         X x;
         {
@@ -113,5 +109,4 @@ int main()
             assert(Z::dtor_called == true);
         }
     }
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.object/optional.object.assign/move.pass.cpp b/test/std/experimental/optional/optional.object/optional.object.assign/move.pass.cpp
index 3e084e5b7dc2..fa00f5602c7f 100644
--- a/test/std/experimental/optional/optional.object/optional.object.assign/move.pass.cpp
+++ b/test/std/experimental/optional/optional.object/optional.object.assign/move.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // XFAIL: libcpp-no-exceptions
 // <optional>
 
@@ -18,8 +19,6 @@
 #include <type_traits>
 #include <cassert>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 
 struct X
@@ -42,11 +41,8 @@ struct Y {};
 
 bool X::throw_now = false;
 
-#endif  // _LIBCPP_STD_VER > 11
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     {
         static_assert(std::is_nothrow_move_assignable<optional<int>>::value, "");
         optional<int> opt;
@@ -100,5 +96,4 @@ int main()
     {
         static_assert(std::is_nothrow_move_assignable<optional<Y>>::value, "");
     }
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.object/optional.object.assign/nullopt_t.pass.cpp b/test/std/experimental/optional/optional.object/optional.object.assign/nullopt_t.pass.cpp
index 7f39744f0557..b1d851b32f4c 100644
--- a/test/std/experimental/optional/optional.object/optional.object.assign/nullopt_t.pass.cpp
+++ b/test/std/experimental/optional/optional.object/optional.object.assign/nullopt_t.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // optional<T>& operator=(nullopt_t) noexcept;
@@ -15,8 +16,6 @@
 #include <type_traits>
 #include <cassert>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 using std::experimental::nullopt_t;
 using std::experimental::nullopt;
@@ -29,11 +28,8 @@ struct X
 
 bool X::dtor_called = false;
 
-#endif  // _LIBCPP_STD_VER > 11
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     {
         optional<int> opt;
         static_assert(noexcept(opt = nullopt) == true, "");
@@ -63,5 +59,4 @@ int main()
             assert(static_cast<bool>(opt) == false);
         }
     }
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.object/optional.object.ctor/copy.pass.cpp b/test/std/experimental/optional/optional.object/optional.object.ctor/copy.pass.cpp
index 7d401de1d978..144af2e3a7dc 100644
--- a/test/std/experimental/optional/optional.object/optional.object.ctor/copy.pass.cpp
+++ b/test/std/experimental/optional/optional.object/optional.object.ctor/copy.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // XFAIL: libcpp-no-exceptions
 // <optional>
 
@@ -16,8 +17,6 @@
 #include <type_traits>
 #include <cassert>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 
 template <class T>
@@ -76,11 +75,8 @@ public:
 };
 
 
-#endif  // _LIBCPP_STD_VER > 11
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     {
         typedef int T;
         optional<T> rhs;
@@ -121,5 +117,4 @@ int main()
         optional<T> rhs(Z(3));
         test(rhs, true);
     }
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.object/optional.object.ctor/default.pass.cpp b/test/std/experimental/optional/optional.object/optional.object.ctor/default.pass.cpp
index 6a1763de22bd..d24a1ac69b86 100644
--- a/test/std/experimental/optional/optional.object/optional.object.ctor/default.pass.cpp
+++ b/test/std/experimental/optional/optional.object/optional.object.ctor/default.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // constexpr optional() noexcept;
@@ -15,8 +16,6 @@
 #include <type_traits>
 #include <cassert>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 
 template <class Opt>
@@ -55,13 +54,9 @@ struct X
     X();
 };
 
-#endif  // _LIBCPP_STD_VER > 11
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     test_constexpr<optional<int>>();
     test_constexpr<optional<int*>>();
     test<optional<X>>();
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.object/optional.object.ctor/in_place_t.pass.cpp b/test/std/experimental/optional/optional.object/optional.object.ctor/in_place_t.pass.cpp
index 014ee859e8a9..dc1666b10362 100644
--- a/test/std/experimental/optional/optional.object/optional.object.ctor/in_place_t.pass.cpp
+++ b/test/std/experimental/optional/optional.object/optional.object.ctor/in_place_t.pass.cpp
@@ -69,7 +69,7 @@ int main()
         struct test_constexpr_ctor
             : public optional<int>
         {
-            constexpr test_constexpr_ctor(in_place_t, int i) 
+            constexpr test_constexpr_ctor(in_place_t, int i)
                 : optional<int>(in_place, i) {}
         };
 
@@ -97,7 +97,7 @@ int main()
         struct test_constexpr_ctor
             : public optional<Y>
         {
-            constexpr test_constexpr_ctor(in_place_t) 
+            constexpr test_constexpr_ctor(in_place_t)
                 : optional<Y>(in_place) {}
         };
 
@@ -110,7 +110,7 @@ int main()
         struct test_constexpr_ctor
             : public optional<Y>
         {
-            constexpr test_constexpr_ctor(in_place_t, int i) 
+            constexpr test_constexpr_ctor(in_place_t, int i)
                 : optional<Y>(in_place, i) {}
         };
 
@@ -123,7 +123,7 @@ int main()
         struct test_constexpr_ctor
             : public optional<Y>
         {
-            constexpr test_constexpr_ctor(in_place_t, int i, int j) 
+            constexpr test_constexpr_ctor(in_place_t, int i, int j)
                 : optional<Y>(in_place, i, j) {}
         };
 
diff --git a/test/std/experimental/optional/optional.object/optional.object.ctor/initializer_list.pass.cpp b/test/std/experimental/optional/optional.object/optional.object.ctor/initializer_list.pass.cpp
index 7a98e0bf31f3..9bd6b18989fc 100644
--- a/test/std/experimental/optional/optional.object/optional.object.ctor/initializer_list.pass.cpp
+++ b/test/std/experimental/optional/optional.object/optional.object.ctor/initializer_list.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // XFAIL: libcpp-no-exceptions
 // <optional>
 
@@ -19,8 +20,6 @@
 #include <vector>
 #include <cassert>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 using std::experimental::in_place_t;
 using std::experimental::in_place;
@@ -60,19 +59,15 @@ class Z
 public:
     constexpr Z() : i_(0) {}
     constexpr Z(int i) : i_(i) {}
-    constexpr Z(std::initializer_list<int> il) : i_(il.begin()[0]), j_(il.begin()[1])
+    Z(std::initializer_list<int> il) : i_(il.begin()[0]), j_(il.begin()[1])
         {throw 6;}
 
     friend constexpr bool operator==(const Z& x, const Z& y)
         {return x.i_ == y.i_ && x.j_ == y.j_;}
 };
 
-
-#endif  // _LIBCPP_STD_VER > 11
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     {
         static_assert(!std::is_constructible<X, std::initializer_list<int>&>::value, "");
         static_assert(!std::is_constructible<optional<X>, std::initializer_list<int>&>::value, "");
@@ -98,10 +93,12 @@ int main()
         struct test_constexpr_ctor
             : public optional<Y>
         {
-            constexpr test_constexpr_ctor(in_place_t, std::initializer_list<int> i) 
+            constexpr test_constexpr_ctor(in_place_t, std::initializer_list<int> i)
                 : optional<Y>(in_place, i) {}
         };
 
+        constexpr test_constexpr_ctor dopt(in_place, {42, 101, -1});
+        static_assert(*dopt == Y{42, 101, -1}, "");
     }
     {
         static_assert(std::is_constructible<optional<Z>, std::initializer_list<int>&>::value, "");
@@ -114,14 +111,5 @@ int main()
         {
             assert(i == 6);
         }
-
-        struct test_constexpr_ctor
-            : public optional<Z>
-        {
-            constexpr test_constexpr_ctor(in_place_t, std::initializer_list<int> i) 
-                : optional<Z>(in_place, i) {}
-        };
-
     }
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.object/optional.object.ctor/move.pass.cpp b/test/std/experimental/optional/optional.object/optional.object.ctor/move.pass.cpp
index 40d55f918993..851157f960f9 100644
--- a/test/std/experimental/optional/optional.object/optional.object.ctor/move.pass.cpp
+++ b/test/std/experimental/optional/optional.object/optional.object.ctor/move.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // XFAIL: libcpp-no-exceptions
 // <optional>
 
@@ -16,8 +17,6 @@
 #include <type_traits>
 #include <cassert>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 
 template <class T>
@@ -75,12 +74,8 @@ public:
     friend constexpr bool operator==(const Z& x, const Z& y) {return x.i_ == y.i_;}
 };
 
-
-#endif  // _LIBCPP_STD_VER > 11
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     {
         typedef int T;
         optional<T> rhs;
@@ -121,5 +116,4 @@ int main()
         optional<T> rhs(Z(3));
         test(rhs, true);
     }
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.object/optional.object.ctor/nullopt_t.pass.cpp b/test/std/experimental/optional/optional.object/optional.object.ctor/nullopt_t.pass.cpp
index c307a2e1e258..40c96581ed84 100644
--- a/test/std/experimental/optional/optional.object/optional.object.ctor/nullopt_t.pass.cpp
+++ b/test/std/experimental/optional/optional.object/optional.object.ctor/nullopt_t.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // constexpr optional(nullopt_t) noexcept;
@@ -15,8 +16,6 @@
 #include <type_traits>
 #include <cassert>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 using std::experimental::nullopt_t;
 using std::experimental::nullopt;
@@ -56,13 +55,9 @@ struct X
     X();
 };
 
-#endif  // _LIBCPP_STD_VER > 11
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     test_constexpr<optional<int>>();
     test_constexpr<optional<int*>>();
     test<optional<X>>();
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.object/optional.object.dtor/dtor.pass.cpp b/test/std/experimental/optional/optional.object/optional.object.dtor/dtor.pass.cpp
index 2697799f0e5e..2bec19e6b4f4 100644
--- a/test/std/experimental/optional/optional.object/optional.object.dtor/dtor.pass.cpp
+++ b/test/std/experimental/optional/optional.object/optional.object.dtor/dtor.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // ~optional();
@@ -15,8 +16,6 @@
 #include <type_traits>
 #include <cassert>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 
 class X
@@ -29,11 +28,8 @@ public:
 
 bool X::dtor_called = false;
 
-#endif  // _LIBCPP_STD_VER > 11
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     {
         typedef int T;
         static_assert(std::is_trivially_destructible<T>::value, "");
@@ -55,5 +51,4 @@ int main()
         }
         assert(X::dtor_called == true);
     }
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.object/optional.object.observe/bool.pass.cpp b/test/std/experimental/optional/optional.object/optional.object.observe/bool.pass.cpp
index a3724375cf4d..a5bfae240073 100644
--- a/test/std/experimental/optional/optional.object/optional.object.observe/bool.pass.cpp
+++ b/test/std/experimental/optional/optional.object/optional.object.observe/bool.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // constexpr explicit optional<T>::operator bool() const noexcept;
@@ -17,7 +18,6 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     using std::experimental::optional;
 
     {
@@ -28,5 +28,4 @@ int main()
         constexpr optional<int> opt(0);
         static_assert(opt, "");
     }
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.object/optional.object.observe/dereference.pass.cpp b/test/std/experimental/optional/optional.object/optional.object.observe/dereference.pass.cpp
index 98e5dac9719e..faba8d256067 100644
--- a/test/std/experimental/optional/optional.object/optional.object.observe/dereference.pass.cpp
+++ b/test/std/experimental/optional/optional.object/optional.object.observe/dereference.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // T& optional<T>::operator*();
@@ -19,8 +20,6 @@
 #include <type_traits>
 #include <cassert>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 
 struct X
@@ -29,11 +28,8 @@ struct X
     int test() {return 4;}
 };
 
-#endif  // _LIBCPP_STD_VER > 11
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     {
         optional<X> opt(X{});
         assert((*opt).test() == 4);
@@ -45,5 +41,4 @@ int main()
         assert(false);
     }
 #endif  // _LIBCPP_DEBUG
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.object/optional.object.observe/dereference_const.pass.cpp b/test/std/experimental/optional/optional.object/optional.object.observe/dereference_const.pass.cpp
index c72a57852a32..f1bdc36424da 100644
--- a/test/std/experimental/optional/optional.object/optional.object.observe/dereference_const.pass.cpp
+++ b/test/std/experimental/optional/optional.object/optional.object.observe/dereference_const.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // constexpr const T& optional<T>::operator*() const;
@@ -19,8 +20,6 @@
 #include <type_traits>
 #include <cassert>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 
 struct X
@@ -33,11 +32,8 @@ struct Y
     int test() const {return 2;}
 };
 
-#endif  // _LIBCPP_STD_VER > 11
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     {
         constexpr optional<X> opt(X{});
         static_assert((*opt).test() == 3, "");
@@ -53,5 +49,4 @@ int main()
         assert(false);
     }
 #endif  // _LIBCPP_DEBUG
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.object/optional.object.observe/op_arrow.pass.cpp b/test/std/experimental/optional/optional.object/optional.object.observe/op_arrow.pass.cpp
index b17fcf8d3050..954ccd71ff53 100644
--- a/test/std/experimental/optional/optional.object/optional.object.observe/op_arrow.pass.cpp
+++ b/test/std/experimental/optional/optional.object/optional.object.observe/op_arrow.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // constexpr T* optional<T>::operator->();
@@ -19,8 +20,6 @@
 #include <type_traits>
 #include <cassert>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 
 struct X
@@ -28,11 +27,8 @@ struct X
     constexpr int test() const {return 3;}
 };
 
-#endif  // _LIBCPP_STD_VER > 11
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     {
         constexpr optional<X> opt(X{});
         static_assert(opt->test() == 3, "");
@@ -44,5 +40,4 @@ int main()
         assert(false);
     }
 #endif  // _LIBCPP_DEBUG
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.object/optional.object.observe/op_arrow_const.pass.cpp b/test/std/experimental/optional/optional.object/optional.object.observe/op_arrow_const.pass.cpp
index e813dd992a5b..cf900d7029e1 100644
--- a/test/std/experimental/optional/optional.object/optional.object.observe/op_arrow_const.pass.cpp
+++ b/test/std/experimental/optional/optional.object/optional.object.observe/op_arrow_const.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // constexpr const T* optional<T>::operator->() const;
@@ -19,8 +20,6 @@
 #include <type_traits>
 #include <cassert>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 
 struct X
@@ -39,11 +38,8 @@ struct Z
     constexpr int test() const {return 1;}
 };
 
-#endif  // _LIBCPP_STD_VER > 11
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     {
         constexpr optional<X> opt(X{});
         static_assert(opt->test() == 3, "");
@@ -63,5 +59,4 @@ int main()
         assert(false);
     }
 #endif  // _LIBCPP_DEBUG
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.object/optional.object.observe/value.pass.cpp b/test/std/experimental/optional/optional.object/optional.object.observe/value.pass.cpp
index 85f9be6998a0..b998f3067f4f 100644
--- a/test/std/experimental/optional/optional.object/optional.object.observe/value.pass.cpp
+++ b/test/std/experimental/optional/optional.object/optional.object.observe/value.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // XFAIL: libcpp-no-exceptions
 // <optional>
 
@@ -16,8 +17,6 @@
 #include <type_traits>
 #include <cassert>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 using std::experimental::bad_optional_access;
 
@@ -29,11 +28,8 @@ struct X
     int test() {return 4;}
 };
 
-#endif  // _LIBCPP_STD_VER > 11
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     {
         optional<X> opt;
         opt.emplace();
@@ -50,5 +46,4 @@ int main()
         {
         }
     }
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.object/optional.object.observe/value_const.fail.cpp b/test/std/experimental/optional/optional.object/optional.object.observe/value_const.fail.cpp
index f0f8af6da45d..baad3b47f3ec 100644
--- a/test/std/experimental/optional/optional.object/optional.object.observe/value_const.fail.cpp
+++ b/test/std/experimental/optional/optional.object/optional.object.observe/value_const.fail.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // constexpr const T& optional<T>::value() const;
@@ -15,8 +16,6 @@
 #include <type_traits>
 #include <cassert>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 
 struct X
@@ -25,16 +24,10 @@ struct X
     int test() {return 4;}
 };
 
-#endif  // _LIBCPP_STD_VER > 11
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     {
         constexpr optional<X> opt;
         static_assert(opt.value().test() == 3, "");
     }
-#else
-#error
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.object/optional.object.observe/value_const.pass.cpp b/test/std/experimental/optional/optional.object/optional.object.observe/value_const.pass.cpp
index c99baab8b6e4..a38b1f930c72 100644
--- a/test/std/experimental/optional/optional.object/optional.object.observe/value_const.pass.cpp
+++ b/test/std/experimental/optional/optional.object/optional.object.observe/value_const.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // XFAIL: libcpp-no-exceptions
 // <optional>
 
@@ -16,8 +17,6 @@
 #include <type_traits>
 #include <cassert>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 using std::experimental::in_place_t;
 using std::experimental::in_place;
@@ -31,11 +30,8 @@ struct X
     int test() {return 4;}
 };
 
-#endif  // _LIBCPP_STD_VER > 11
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     {
         constexpr optional<X> opt(in_place);
         static_assert(opt.value().test() == 3, "");
@@ -55,5 +51,4 @@ int main()
         {
         }
     }
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.object/optional.object.observe/value_or.pass.cpp b/test/std/experimental/optional/optional.object/optional.object.observe/value_or.pass.cpp
index 6118c44bb5ba..6fca8c82cebd 100644
--- a/test/std/experimental/optional/optional.object/optional.object.observe/value_or.pass.cpp
+++ b/test/std/experimental/optional/optional.object/optional.object.observe/value_or.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // template <class U> T optional<T>::value_or(U&& v) &&;
@@ -15,8 +16,6 @@
 #include <type_traits>
 #include <cassert>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 using std::experimental::in_place_t;
 using std::experimental::in_place;
@@ -40,11 +39,8 @@ struct X
         {return x.i_ == y.i_;}
 };
 
-#endif  // _LIBCPP_STD_VER > 11
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     {
         optional<X> opt(in_place, 2);
         Y y(3);
@@ -67,5 +63,4 @@ int main()
         assert(std::move(opt).value_or(Y(3)) == 4);
         assert(!opt);
     }
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.object/optional.object.observe/value_or_const.pass.cpp b/test/std/experimental/optional/optional.object/optional.object.observe/value_or_const.pass.cpp
index d51f18abbd28..4a008dce2386 100644
--- a/test/std/experimental/optional/optional.object/optional.object.observe/value_or_const.pass.cpp
+++ b/test/std/experimental/optional/optional.object/optional.object.observe/value_or_const.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // template <class U> constexpr T optional<T>::value_or(U&& v) const&;
@@ -15,8 +16,6 @@
 #include <type_traits>
 #include <cassert>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 
 struct Y
@@ -37,11 +36,8 @@ struct X
         {return x.i_ == y.i_;}
 };
 
-#endif  // _LIBCPP_STD_VER > 11
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     {
         constexpr optional<X> opt(2);
         constexpr Y y(3);
@@ -78,5 +74,4 @@ int main()
         const optional<X> opt;
         assert(opt.value_or(Y(3)) == 4);
     }
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.object/optional.object.swap/swap.pass.cpp b/test/std/experimental/optional/optional.object/optional.object.swap/swap.pass.cpp
index d24a2d06b9d5..620dda19e3ff 100644
--- a/test/std/experimental/optional/optional.object/optional.object.swap/swap.pass.cpp
+++ b/test/std/experimental/optional/optional.object/optional.object.swap/swap.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // XFAIL: libcpp-no-exceptions
 // <optional>
 
@@ -18,8 +19,6 @@
 #include <type_traits>
 #include <cassert>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 
 class X
@@ -63,12 +62,8 @@ public:
     friend void swap(Z& x, Z& y) {throw 6;}
 };
 
-
-#endif  // _LIBCPP_STD_VER > 11
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     {
         optional<int> opt1;
         optional<int> opt2;
@@ -303,5 +298,4 @@ int main()
         assert(static_cast<bool>(opt2) == true);
         assert(*opt2 == 2);
     }
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.object/optional_const_void.fail.cpp b/test/std/experimental/optional/optional.object/optional_const_void.fail.cpp
index 6999cf2451f1..02c0a3a63a5e 100644
--- a/test/std/experimental/optional/optional.object/optional_const_void.fail.cpp
+++ b/test/std/experimental/optional/optional.object/optional_const_void.fail.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // T shall be an object type and shall satisfy the requirements of Destructible
@@ -15,11 +16,7 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     using std::experimental::optional;
 
     optional<const void> opt;
-#else
-#error
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.object/optional_not_destructible.fail.cpp b/test/std/experimental/optional/optional.object/optional_not_destructible.fail.cpp
index 61470af01195..da8bd05f2c9b 100644
--- a/test/std/experimental/optional/optional.object/optional_not_destructible.fail.cpp
+++ b/test/std/experimental/optional/optional.object/optional_not_destructible.fail.cpp
@@ -7,14 +7,13 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // T shall be an object type and shall satisfy the requirements of Destructible
 
 #include <experimental/optional>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 
 struct X
@@ -23,13 +22,7 @@ private:
     ~X() {}
 };
 
-#endif  // _LIBCPP_STD_VER > 11
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     optional<X> opt;
-#else
-#error
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.object/optional_not_noexcept_destructible.fail.cpp b/test/std/experimental/optional/optional.object/optional_not_noexcept_destructible.fail.cpp
index eaee02014c2f..7aa179afeaf6 100644
--- a/test/std/experimental/optional/optional.object/optional_not_noexcept_destructible.fail.cpp
+++ b/test/std/experimental/optional/optional.object/optional_not_noexcept_destructible.fail.cpp
@@ -7,14 +7,13 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // T shall be an object type and shall satisfy the requirements of Destructible
 
 #include <experimental/optional>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 
 struct X
@@ -22,13 +21,7 @@ struct X
     ~X() noexcept(false) {}
 };
 
-#endif  // _LIBCPP_STD_VER > 11
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     optional<X> opt;
-#else
-#error
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.object/optional_void.fail.cpp b/test/std/experimental/optional/optional.object/optional_void.fail.cpp
index f911e9a2d6d4..73f689c56720 100644
--- a/test/std/experimental/optional/optional.object/optional_void.fail.cpp
+++ b/test/std/experimental/optional/optional.object/optional_void.fail.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // T shall be an object type and shall satisfy the requirements of Destructible
@@ -15,11 +16,7 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     using std::experimental::optional;
 
     optional<void> opt;
-#else
-#error
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.object/types.pass.cpp b/test/std/experimental/optional/optional.object/types.pass.cpp
index 8b9ad2e19570..af8da2df8fd5 100644
--- a/test/std/experimental/optional/optional.object/types.pass.cpp
+++ b/test/std/experimental/optional/optional.object/types.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // template <class T>
@@ -19,8 +20,6 @@
 #include <experimental/optional>
 #include <type_traits>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 
 template <class Opt, class T>
@@ -30,14 +29,10 @@ test()
     static_assert(std::is_same<typename Opt::value_type, T>::value, "");
 }
 
-#endif  // _LIBCPP_STD_VER > 11
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     test<optional<int>, int>();
     test<optional<const int>, const int>();
     test<optional<double>, double>();
     test<optional<const double>, const double>();
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.relops/equal.pass.cpp b/test/std/experimental/optional/optional.relops/equal.pass.cpp
index 03b9d3fda5cf..413e7c8b3780 100644
--- a/test/std/experimental/optional/optional.relops/equal.pass.cpp
+++ b/test/std/experimental/optional/optional.relops/equal.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // template <class T> constexpr bool operator==(const optional<T>& x, const optional<T>& y);
@@ -15,8 +16,6 @@
 #include <type_traits>
 #include <cassert>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 
 struct X
@@ -28,16 +27,13 @@ struct X
 
 constexpr bool operator == ( const X &lhs, const X &rhs )
     { return lhs.i_ == rhs.i_ ; }
-    
-#endif
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     {
     typedef X T;
     typedef optional<T> O;
-    
+
     constexpr O o1;     // disengaged
     constexpr O o2;     // disengaged
     constexpr O o3{1};  // engaged
@@ -75,5 +71,4 @@ int main()
     static_assert (   o5 == o5 , "" );
 
     }
-#endif
 }
diff --git a/test/std/experimental/optional/optional.relops/greater_equal.pass.cpp b/test/std/experimental/optional/optional.relops/greater_equal.pass.cpp
index 98d6855f9313..c0739dda6b83 100644
--- a/test/std/experimental/optional/optional.relops/greater_equal.pass.cpp
+++ b/test/std/experimental/optional/optional.relops/greater_equal.pass.cpp
@@ -7,14 +7,13 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // template <class T> constexpr bool operator>= (const optional<T>& x, const optional<T>& y);
 
 #include <experimental/optional>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 
 struct X
@@ -27,20 +26,17 @@ struct X
 constexpr bool operator < ( const X &lhs, const X &rhs )
     { return lhs.i_ < rhs.i_ ; }
 
-#endif
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     {
     typedef optional<X> O;
-    
+
     constexpr O o1;     // disengaged
     constexpr O o2;     // disengaged
     constexpr O o3{1};  // engaged
     constexpr O o4{2};  // engaged
     constexpr O o5{1};  // engaged
-    
+
     static_assert (  (o1 >= o1), "" );
     static_assert (  (o1 >= o2), "" );
     static_assert ( !(o1 >= o3), "" );
@@ -71,5 +67,4 @@ int main()
     static_assert ( !(o5 >= o4), "" );
     static_assert (  (o5 >= o5), "" );
     }
-#endif
 }
diff --git a/test/std/experimental/optional/optional.relops/greater_than.pass.cpp b/test/std/experimental/optional/optional.relops/greater_than.pass.cpp
index d51bd4f2ac46..df7dbb64717f 100644
--- a/test/std/experimental/optional/optional.relops/greater_than.pass.cpp
+++ b/test/std/experimental/optional/optional.relops/greater_than.pass.cpp
@@ -7,14 +7,13 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // template <class T> constexpr bool operator> (const optional<T>& x, const optional<T>& y);
 
 #include <experimental/optional>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 
 struct X
@@ -27,20 +26,17 @@ struct X
 constexpr bool operator < ( const X &lhs, const X &rhs )
     { return lhs.i_ < rhs.i_ ; }
 
-#endif
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     {
     typedef optional<X> O;
-    
+
     constexpr O o1;     // disengaged
     constexpr O o2;     // disengaged
     constexpr O o3{1};  // engaged
     constexpr O o4{2};  // engaged
     constexpr O o5{1};  // engaged
-    
+
     static_assert ( !(o1 > o1), "" );
     static_assert ( !(o1 > o2), "" );
     static_assert ( !(o1 > o3), "" );
@@ -71,5 +67,4 @@ int main()
     static_assert ( !(o5 > o4), "" );
     static_assert ( !(o5 > o5), "" );
     }
-#endif
 }
diff --git a/test/std/experimental/optional/optional.relops/less_equal.pass.cpp b/test/std/experimental/optional/optional.relops/less_equal.pass.cpp
index 326f3a896493..d4874d17b240 100644
--- a/test/std/experimental/optional/optional.relops/less_equal.pass.cpp
+++ b/test/std/experimental/optional/optional.relops/less_equal.pass.cpp
@@ -7,14 +7,13 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // template <class T> constexpr bool operator<= (const optional<T>& x, const optional<T>& y);
 
 #include <experimental/optional>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 
 struct X
@@ -27,20 +26,17 @@ struct X
 constexpr bool operator < ( const X &lhs, const X &rhs )
     { return lhs.i_ < rhs.i_ ; }
 
-#endif
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     {
     typedef optional<X> O;
-    
+
     constexpr O o1;     // disengaged
     constexpr O o2;     // disengaged
     constexpr O o3{1};  // engaged
     constexpr O o4{2};  // engaged
     constexpr O o5{1};  // engaged
-    
+
     static_assert (  (o1 <= o1), "" );
     static_assert (  (o1 <= o2), "" );
     static_assert (  (o1 <= o3), "" );
@@ -71,5 +67,4 @@ int main()
     static_assert (  (o5 <= o4), "" );
     static_assert (  (o5 <= o5), "" );
     }
-#endif
 }
diff --git a/test/std/experimental/optional/optional.relops/less_than.pass.cpp b/test/std/experimental/optional/optional.relops/less_than.pass.cpp
index 37f7e1942982..4113408268e8 100644
--- a/test/std/experimental/optional/optional.relops/less_than.pass.cpp
+++ b/test/std/experimental/optional/optional.relops/less_than.pass.cpp
@@ -7,14 +7,13 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // template <class T> constexpr bool operator< (const optional<T>& x, const optional<T>& y);
 
 #include <experimental/optional>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 
 struct X
@@ -27,20 +26,17 @@ struct X
 constexpr bool operator < ( const X &lhs, const X &rhs )
     { return lhs.i_ < rhs.i_ ; }
 
-#endif
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     {
     typedef optional<X> O;
-    
+
     constexpr O o1;     // disengaged
     constexpr O o2;     // disengaged
     constexpr O o3{1};  // engaged
     constexpr O o4{2};  // engaged
     constexpr O o5{1};  // engaged
-    
+
     static_assert ( !(o1 < o1), "" );
     static_assert ( !(o1 < o2), "" );
     static_assert (  (o1 < o3), "" );
@@ -71,5 +67,4 @@ int main()
     static_assert (  (o5 < o4), "" );
     static_assert ( !(o5 < o5), "" );
     }
-#endif
 }
diff --git a/test/std/experimental/optional/optional.relops/not_equal.pass.cpp b/test/std/experimental/optional/optional.relops/not_equal.pass.cpp
index f386c7e361ec..19a196317d4f 100644
--- a/test/std/experimental/optional/optional.relops/not_equal.pass.cpp
+++ b/test/std/experimental/optional/optional.relops/not_equal.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // template <class T> constexpr bool operator!=(const optional<T>& x, const optional<T>& y);
@@ -15,8 +16,6 @@
 #include <type_traits>
 #include <cassert>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 
 struct X
@@ -28,16 +27,13 @@ struct X
 
 constexpr bool operator == ( const X &lhs, const X &rhs )
     { return lhs.i_ == rhs.i_ ; }
-    
-#endif
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     {
     typedef X T;
     typedef optional<T> O;
-    
+
     constexpr O o1;     // disengaged
     constexpr O o2;     // disengaged
     constexpr O o3{1};  // engaged
@@ -75,5 +71,4 @@ int main()
     static_assert ( !(o5 != o5), "" );
 
     }
-#endif
 }
diff --git a/test/std/experimental/optional/optional.specalg/make_optional.pass.cpp b/test/std/experimental/optional/optional.specalg/make_optional.pass.cpp
index cc95e6110e8d..9abd87bd4051 100644
--- a/test/std/experimental/optional/optional.specalg/make_optional.pass.cpp
+++ b/test/std/experimental/optional/optional.specalg/make_optional.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // template <class T>
@@ -19,9 +20,10 @@
 #include <memory>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     using std::experimental::optional;
     using std::experimental::make_optional;
 
@@ -38,7 +40,7 @@ int main()
         std::string s("123");
         optional<std::string> opt = make_optional(std::move(s));
         assert(*opt == "123");
-        assert(s.empty());
+        LIBCPP_ASSERT(s.empty());
     }
     {
         std::unique_ptr<int> s(new int(3));
@@ -46,5 +48,4 @@ int main()
         assert(**opt == 3);
         assert(s == nullptr);
     }
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.specalg/swap.pass.cpp b/test/std/experimental/optional/optional.specalg/swap.pass.cpp
index 6c5f7b0e860c..d339c53c1f77 100644
--- a/test/std/experimental/optional/optional.specalg/swap.pass.cpp
+++ b/test/std/experimental/optional/optional.specalg/swap.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // XFAIL: libcpp-no-exceptions
 // <optional>
 
@@ -17,8 +18,6 @@
 #include <type_traits>
 #include <cassert>
 
-#if _LIBCPP_STD_VER > 11
-
 using std::experimental::optional;
 
 class X
@@ -62,12 +61,8 @@ public:
     friend void swap(Z& x, Z& y) {throw 6;}
 };
 
-
-#endif  // _LIBCPP_STD_VER > 11
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     {
         optional<int> opt1;
         optional<int> opt2;
@@ -302,5 +297,4 @@ int main()
         assert(static_cast<bool>(opt2) == true);
         assert(*opt2 == 2);
     }
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.syn/optional_const_in_place_t.fail.cpp b/test/std/experimental/optional/optional.syn/optional_const_in_place_t.fail.cpp
index 60836ae2396e..bdf01eba406f 100644
--- a/test/std/experimental/optional/optional.syn/optional_const_in_place_t.fail.cpp
+++ b/test/std/experimental/optional/optional.syn/optional_const_in_place_t.fail.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // A program that necessitates the instantiation of template optional for
@@ -16,13 +17,9 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     using std::experimental::optional;
     using std::experimental::in_place_t;
     using std::experimental::in_place;
 
     optional<const in_place_t> opt;
-#else
-#error
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.syn/optional_const_lvalue_ref.fail.cpp b/test/std/experimental/optional/optional.syn/optional_const_lvalue_ref.fail.cpp
index 9a4ba1a027a1..61393c105e95 100644
--- a/test/std/experimental/optional/optional.syn/optional_const_lvalue_ref.fail.cpp
+++ b/test/std/experimental/optional/optional.syn/optional_const_lvalue_ref.fail.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // A program that necessitates the instantiation of template optional for a
@@ -16,11 +17,7 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     using std::experimental::optional;
 
     optional<const int&> opt;
-#else
-#error
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.syn/optional_const_nullopt_t.fail.cpp b/test/std/experimental/optional/optional.syn/optional_const_nullopt_t.fail.cpp
index f6220bda69c4..89c207306aba 100644
--- a/test/std/experimental/optional/optional.syn/optional_const_nullopt_t.fail.cpp
+++ b/test/std/experimental/optional/optional.syn/optional_const_nullopt_t.fail.cpp
@@ -7,22 +7,19 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // A program that necessitates the instantiation of template optional for
-// (possibly cv-qualified) null_opt_t is ill-formed.
+// (possibly cv-qualified) nullopt_t is ill-formed.
 
 #include <experimental/optional>
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     using std::experimental::optional;
     using std::experimental::nullopt_t;
     using std::experimental::nullopt;
 
     optional<const nullopt_t> opt;
-#else
-#error
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.syn/optional_in_place_t.fail.cpp b/test/std/experimental/optional/optional.syn/optional_in_place_t.fail.cpp
index 12f291fcd228..47c2be7da0d0 100644
--- a/test/std/experimental/optional/optional.syn/optional_in_place_t.fail.cpp
+++ b/test/std/experimental/optional/optional.syn/optional_in_place_t.fail.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // A program that necessitates the instantiation of template optional for
@@ -16,13 +17,9 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     using std::experimental::optional;
     using std::experimental::in_place_t;
     using std::experimental::in_place;
 
     optional<in_place_t> opt;
-#else
-#error
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.syn/optional_includes_initializer_list.pass.cpp b/test/std/experimental/optional/optional.syn/optional_includes_initializer_list.pass.cpp
index 7e6697ff6e50..8cf11b553e74 100644
--- a/test/std/experimental/optional/optional.syn/optional_includes_initializer_list.pass.cpp
+++ b/test/std/experimental/optional/optional.syn/optional_includes_initializer_list.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // #include <initializer_list>
@@ -15,9 +16,7 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     using std::experimental::optional;
 
     std::initializer_list<int> list;
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.syn/optional_lvalue_ref.fail.cpp b/test/std/experimental/optional/optional.syn/optional_lvalue_ref.fail.cpp
index 850df342aef0..de2f18991b24 100644
--- a/test/std/experimental/optional/optional.syn/optional_lvalue_ref.fail.cpp
+++ b/test/std/experimental/optional/optional.syn/optional_lvalue_ref.fail.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // A program that necessitates the instantiation of template optional for a
@@ -16,11 +17,7 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     using std::experimental::optional;
 
     optional<int&> opt;
-#else
-#error
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.syn/optional_nullopt_t.fail.cpp b/test/std/experimental/optional/optional.syn/optional_nullopt_t.fail.cpp
index 20955ace834a..3d276d642022 100644
--- a/test/std/experimental/optional/optional.syn/optional_nullopt_t.fail.cpp
+++ b/test/std/experimental/optional/optional.syn/optional_nullopt_t.fail.cpp
@@ -7,22 +7,19 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // A program that necessitates the instantiation of template optional for
-// (possibly cv-qualified) null_opt_t is ill-formed.
+// (possibly cv-qualified) nullopt_t is ill-formed.
 
 #include <experimental/optional>
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     using std::experimental::optional;
     using std::experimental::nullopt_t;
     using std::experimental::nullopt;
 
     optional<nullopt_t> opt;
-#else
-#error
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/optional/optional.syn/optional_rvalue_ref.fail.cpp b/test/std/experimental/optional/optional.syn/optional_rvalue_ref.fail.cpp
index d773e993df22..fd6da18e8c16 100644
--- a/test/std/experimental/optional/optional.syn/optional_rvalue_ref.fail.cpp
+++ b/test/std/experimental/optional/optional.syn/optional_rvalue_ref.fail.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <optional>
 
 // A program that necessitates the instantiation of template optional for a
@@ -16,11 +17,7 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     using std::experimental::optional;
 
     optional<int&&> opt;
-#else
-#error
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/experimental/string.view/string.view.access/at.pass.cpp b/test/std/experimental/string.view/string.view.access/at.pass.cpp
index 46804d4df3af..7ceaf5ab3d9f 100644
--- a/test/std/experimental/string.view/string.view.access/at.pass.cpp
+++ b/test/std/experimental/string.view/string.view.access/at.pass.cpp
@@ -10,7 +10,7 @@
 // NOTE: Older versions of clang have a bug where they fail to evalute
 // string_view::at as a constant expression.
 // XFAIL: clang-3.4, clang-3.3
-// XFAIL: libcpp-no-exceptions
+
 
 // <string_view>
 
@@ -20,6 +20,8 @@
 #include <stdexcept>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <typename CharT>
 void test ( const CharT *s, size_t len ) {
     std::experimental::basic_string_view<CharT> sv ( s, len );
@@ -27,12 +29,14 @@ void test ( const CharT *s, size_t len ) {
     for ( size_t i = 0; i < len; ++i ) {
         assert (  sv.at(i) == s[i] );
         assert ( &sv.at(i) == s + i );
-        }
+    }
 
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try { sv.at(len); } catch ( const std::out_of_range & ) { return ; }
     assert ( false );
-    }
-    
+#endif
+}
+
 int main () {
     test ( "ABCDE", 5 );
     test ( "a", 1 );
@@ -40,7 +44,7 @@ int main () {
     test ( L"ABCDE", 5 );
     test ( L"a", 1 );
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test ( u"ABCDE", 5 );
     test ( u"a", 1 );
 
@@ -48,7 +52,7 @@ int main () {
     test ( U"a", 1 );
 #endif
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     constexpr std::experimental::basic_string_view<char> sv ( "ABC", 2 );
     static_assert ( sv.length() ==  2,  "" );
diff --git a/test/std/experimental/string.view/string.view.access/back.pass.cpp b/test/std/experimental/string.view/string.view.access/back.pass.cpp
index 093a858a4805..09f7950341a8 100644
--- a/test/std/experimental/string.view/string.view.access/back.pass.cpp
+++ b/test/std/experimental/string.view/string.view.access/back.pass.cpp
@@ -15,6 +15,8 @@
 #include <experimental/string_view>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <typename CharT>
 bool test ( const CharT *s, size_t len ) {
     std::experimental::basic_string_view<CharT> sv ( s, len );
@@ -22,7 +24,7 @@ bool test ( const CharT *s, size_t len ) {
     assert ( sv.back() == s[len-1] );
     return &sv.back() == s + len - 1;
     }
-    
+
 int main () {
     assert ( test ( "ABCDE", 5 ));
     assert ( test ( "a", 1 ));
@@ -30,7 +32,7 @@ int main () {
     assert ( test ( L"ABCDE", 5 ));
     assert ( test ( L"a", 1 ));
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     assert ( test ( u"ABCDE", 5 ));
     assert ( test ( u"a", 1 ));
 
@@ -38,7 +40,7 @@ int main () {
     assert ( test ( U"a", 1 ));
 #endif
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     constexpr std::experimental::basic_string_view<char> sv ( "ABC", 2 );
     static_assert ( sv.length() ==  2,  "" );
diff --git a/test/std/experimental/string.view/string.view.access/data.pass.cpp b/test/std/experimental/string.view/string.view.access/data.pass.cpp
index 562a765f50ce..53e95ddaea31 100644
--- a/test/std/experimental/string.view/string.view.access/data.pass.cpp
+++ b/test/std/experimental/string.view/string.view.access/data.pass.cpp
@@ -15,13 +15,15 @@
 #include <experimental/string_view>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <typename CharT>
 void test ( const CharT *s, size_t len ) {
     std::experimental::basic_string_view<CharT> sv ( s, len );
     assert ( sv.length() == len );
     assert ( sv.data() == s );
     }
-    
+
 int main () {
     test ( "ABCDE", 5 );
     test ( "a", 1 );
@@ -29,7 +31,7 @@ int main () {
     test ( L"ABCDE", 5 );
     test ( L"a", 1 );
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test ( u"ABCDE", 5 );
     test ( u"a", 1 );
 
diff --git a/test/std/experimental/string.view/string.view.access/front.pass.cpp b/test/std/experimental/string.view/string.view.access/front.pass.cpp
index e9df44b19b1a..acb00a46a2e5 100644
--- a/test/std/experimental/string.view/string.view.access/front.pass.cpp
+++ b/test/std/experimental/string.view/string.view.access/front.pass.cpp
@@ -15,6 +15,8 @@
 #include <experimental/string_view>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <typename CharT>
 bool test ( const CharT *s, size_t len ) {
     std::experimental::basic_string_view<CharT> sv ( s, len );
@@ -22,7 +24,7 @@ bool test ( const CharT *s, size_t len ) {
     assert ( sv.front() == s[0] );
     return &sv.front() == s;
     }
-    
+
 int main () {
     assert ( test ( "ABCDE", 5 ));
     assert ( test ( "a", 1 ));
@@ -30,7 +32,7 @@ int main () {
     assert ( test ( L"ABCDE", 5 ));
     assert ( test ( L"a", 1 ));
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     assert ( test ( u"ABCDE", 5 ));
     assert ( test ( u"a", 1 ));
 
@@ -38,7 +40,7 @@ int main () {
     assert ( test ( U"a", 1 ));
 #endif
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     constexpr std::experimental::basic_string_view<char> sv ( "ABC", 2 );
     static_assert ( sv.length() ==  2,  "" );
diff --git a/test/std/experimental/string.view/string.view.access/index.pass.cpp b/test/std/experimental/string.view/string.view.access/index.pass.cpp
index 4491207cbb85..2c1bd1dc91cb 100644
--- a/test/std/experimental/string.view/string.view.access/index.pass.cpp
+++ b/test/std/experimental/string.view/string.view.access/index.pass.cpp
@@ -15,6 +15,8 @@
 #include <experimental/string_view>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <typename CharT>
 void test ( const CharT *s, size_t len ) {
     std::experimental::basic_string_view<CharT> sv ( s, len );
@@ -24,7 +26,7 @@ void test ( const CharT *s, size_t len ) {
         assert ( &sv[i] == s + i );
         }
     }
-    
+
 int main () {
     test ( "ABCDE", 5 );
     test ( "a", 1 );
@@ -32,7 +34,7 @@ int main () {
     test ( L"ABCDE", 5 );
     test ( L"a", 1 );
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test ( u"ABCDE", 5 );
     test ( u"a", 1 );
 
diff --git a/test/std/experimental/string.view/string.view.capacity/capacity.pass.cpp b/test/std/experimental/string.view/string.view.capacity/capacity.pass.cpp
index eb802165930d..9f5d86f2f82b 100644
--- a/test/std/experimental/string.view/string.view.capacity/capacity.pass.cpp
+++ b/test/std/experimental/string.view/string.view.capacity/capacity.pass.cpp
@@ -19,6 +19,8 @@
 #include <experimental/string_view>
 #include <cassert>
 
+#include "test_macros.h"
+
 template<typename SV>
 void test1 () {
 #if _LIBCPP_STD_VER > 11
@@ -30,7 +32,7 @@ void test1 () {
     static_assert ( sv1.max_size() > sv1.size(), "");
     }
 #endif
-    
+
     {
     SV sv1;
     assert ( sv1.size() == 0 );
@@ -73,7 +75,7 @@ int main () {
     test2 ( L"a", 1 );
     test2 ( L"", 0 );
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test2 ( u"ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE", 105 );
     test2 ( u"ABCDE", 5 );
     test2 ( u"a", 1 );
diff --git a/test/std/experimental/string.view/string.view.comparison/opeq.string_view.pointer.pass.cpp b/test/std/experimental/string.view/string.view.comparison/opeq.string_view.pointer.pass.cpp
index 148dc18d7ec8..0df37a6ffd9f 100644
--- a/test/std/experimental/string.view/string.view.comparison/opeq.string_view.pointer.pass.cpp
+++ b/test/std/experimental/string.view/string.view.comparison/opeq.string_view.pointer.pass.cpp
@@ -58,7 +58,7 @@ int main()
     static_assert (  ""      == sv1, "" );
     static_assert (!(sv1     == "abcde"), "" );
     static_assert (!("abcde" == sv1), "" );
-    
+
     static_assert (  sv2      == "abcde", "" );
     static_assert (  "abcde"  == sv2, "" );
     static_assert (!(sv2      == "abcde0"), "" );
diff --git a/test/std/experimental/string.view/string.view.comparison/opeq.string_view.string.pass.cpp b/test/std/experimental/string.view/string.view.comparison/opeq.string_view.string.pass.cpp
index 23a2aef242d7..1fd72d7964b6 100644
--- a/test/std/experimental/string.view/string.view.comparison/opeq.string_view.string.pass.cpp
+++ b/test/std/experimental/string.view/string.view.comparison/opeq.string_view.string.pass.cpp
@@ -17,8 +17,6 @@
 #include <experimental/string_view>
 #include <cassert>
 
-#if _LIBCPP_STD_VER > 11
-
 template <class S>
 void
 test(const std::string &lhs, S rhs, bool x)
@@ -49,6 +47,4 @@ int main()
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
     }
 }
-#else
-int main () {}
-#endif
+
diff --git a/test/std/experimental/string.view/string.view.comparison/opge.string_view.pointer.pass.cpp b/test/std/experimental/string.view/string.view.comparison/opge.string_view.pointer.pass.cpp
index f02459b01c49..f5bcb7e97b73 100644
--- a/test/std/experimental/string.view/string.view.comparison/opge.string_view.pointer.pass.cpp
+++ b/test/std/experimental/string.view/string.view.comparison/opge.string_view.pointer.pass.cpp
@@ -59,7 +59,7 @@ int main()
     static_assert (  ""      >= sv1, "" );
     static_assert (!(sv1     >= "abcde"), "" );
     static_assert (  "abcde" >= sv1, "" );
-    
+
     static_assert (  sv2      >= "", "" );
     static_assert (!(""       >= sv2), "" );
     static_assert (  sv2      >= "abcde", "" );
diff --git a/test/std/experimental/string.view/string.view.comparison/opgt.string_view.pointer.pass.cpp b/test/std/experimental/string.view/string.view.comparison/opgt.string_view.pointer.pass.cpp
index 48703cac612f..63002a5c415c 100644
--- a/test/std/experimental/string.view/string.view.comparison/opgt.string_view.pointer.pass.cpp
+++ b/test/std/experimental/string.view/string.view.comparison/opgt.string_view.pointer.pass.cpp
@@ -59,7 +59,7 @@ int main()
     static_assert (!(""      > sv1), "" );
     static_assert (!(sv1     > "abcde"), "" );
     static_assert (  "abcde" > sv1, "" );
-    
+
     static_assert (  sv2      > "", "" );
     static_assert (!(""       > sv2), "" );
     static_assert (!(sv2      > "abcde"), "" );
diff --git a/test/std/experimental/string.view/string.view.comparison/ople.string_view.pointer.pass.cpp b/test/std/experimental/string.view/string.view.comparison/ople.string_view.pointer.pass.cpp
index 539f5fa5402e..c542efea99a7 100644
--- a/test/std/experimental/string.view/string.view.comparison/ople.string_view.pointer.pass.cpp
+++ b/test/std/experimental/string.view/string.view.comparison/ople.string_view.pointer.pass.cpp
@@ -59,7 +59,7 @@ int main()
     static_assert (  ""      <= sv1, "" );
     static_assert (  sv1     <= "abcde", "" );
     static_assert (!("abcde" <= sv1), "" );
-    
+
     static_assert (!(sv2      <= ""), "" );
     static_assert (  ""       <= sv2, "" );
     static_assert (  sv2      <= "abcde", "" );
diff --git a/test/std/experimental/string.view/string.view.comparison/oplt.string_view.pointer.pass.cpp b/test/std/experimental/string.view/string.view.comparison/oplt.string_view.pointer.pass.cpp
index a1013e4d8152..2c0461481e78 100644
--- a/test/std/experimental/string.view/string.view.comparison/oplt.string_view.pointer.pass.cpp
+++ b/test/std/experimental/string.view/string.view.comparison/oplt.string_view.pointer.pass.cpp
@@ -59,7 +59,7 @@ int main()
     static_assert (!(""      < sv1), "" );
     static_assert (  sv1     < "abcde", "" );
     static_assert (!("abcde" < sv1), "" );
-    
+
     static_assert (!(sv2      < ""), "" );
     static_assert (  ""       < sv2, "" );
     static_assert (!(sv2      < "abcde"), "" );
diff --git a/test/std/experimental/string.view/string.view.comparison/opne.string_view.pointer.pass.cpp b/test/std/experimental/string.view/string.view.comparison/opne.string_view.pointer.pass.cpp
index 299be934a811..1deee9ac7fc6 100644
--- a/test/std/experimental/string.view/string.view.comparison/opne.string_view.pointer.pass.cpp
+++ b/test/std/experimental/string.view/string.view.comparison/opne.string_view.pointer.pass.cpp
@@ -59,7 +59,7 @@ int main()
     static_assert (!(""      != sv1), "" );
     static_assert (  sv1     != "abcde", "" );
     static_assert (  "abcde" != sv1, "" );
-    
+
     static_assert (!(sv2      != "abcde"), "" );
     static_assert (!("abcde"  != sv2), "" );
     static_assert (  sv2      != "abcde0",   "" );
diff --git a/test/std/experimental/string.view/string.view.cons/default.pass.cpp b/test/std/experimental/string.view/string.view.cons/default.pass.cpp
index e1d69f4a3dfe..e817bfffb89d 100644
--- a/test/std/experimental/string.view/string.view.cons/default.pass.cpp
+++ b/test/std/experimental/string.view/string.view.cons/default.pass.cpp
@@ -24,7 +24,7 @@ void test () {
     static_assert ( sv1.empty(), "");
     }
 #endif
-    
+
     {
     T sv1;
     assert ( sv1.size() == 0 );
diff --git a/test/std/experimental/string.view/string.view.cons/from_literal.pass.cpp b/test/std/experimental/string.view/string.view.cons/from_literal.pass.cpp
index 82d0d7954149..9de3a3039523 100644
--- a/test/std/experimental/string.view/string.view.cons/from_literal.pass.cpp
+++ b/test/std/experimental/string.view/string.view.cons/from_literal.pass.cpp
@@ -40,12 +40,12 @@ int main () {
     test ( "QBCDE" );
     test ( "A" );
     test ( "" );
-    
+
     test ( L"QBCDE" );
     test ( L"A" );
     test ( L"" );
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test ( u"QBCDE" );
     test ( u"A" );
     test ( u"" );
diff --git a/test/std/experimental/string.view/string.view.cons/from_ptr_len.pass.cpp b/test/std/experimental/string.view/string.view.cons/from_ptr_len.pass.cpp
index 1038d0484f8c..663d25e954f9 100644
--- a/test/std/experimental/string.view/string.view.cons/from_ptr_len.pass.cpp
+++ b/test/std/experimental/string.view/string.view.cons/from_ptr_len.pass.cpp
@@ -18,6 +18,8 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
+
 template<typename CharT>
 void test ( const CharT *s, size_t sz ) {
     {
@@ -53,7 +55,7 @@ int main () {
     }
 #endif
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test ( u"QBCDE", 5 );
     test ( u"QBCDE", 2 );
     test ( u"", 0 );
diff --git a/test/std/experimental/string.view/string.view.cons/from_string.pass.cpp b/test/std/experimental/string.view/string.view.cons/from_string.pass.cpp
index 670c033a653f..4ecd2cdff9ba 100644
--- a/test/std/experimental/string.view/string.view.cons/from_string.pass.cpp
+++ b/test/std/experimental/string.view/string.view.cons/from_string.pass.cpp
@@ -18,6 +18,8 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
+
 struct dummy_char_traits : public std::char_traits<char> {};
 
 template<typename CharT, typename Traits>
@@ -32,12 +34,12 @@ int main () {
     test ( std::string("QBCDE") );
     test ( std::string("") );
     test ( std::string() );
-    
+
     test ( std::wstring(L"QBCDE") );
     test ( std::wstring(L"") );
     test ( std::wstring() );
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test ( std::u16string{u"QBCDE"} );
     test ( std::u16string{u""} );
     test ( std::u16string{} );
@@ -46,7 +48,7 @@ int main () {
     test ( std::u32string{U""} );
     test ( std::u32string{} );
 #endif
-    
+
     test ( std::basic_string<char, dummy_char_traits>("QBCDE") );
     test ( std::basic_string<char, dummy_char_traits>("") );
     test ( std::basic_string<char, dummy_char_traits>() );
diff --git a/test/std/experimental/string.view/string.view.cons/from_string1.fail.cpp b/test/std/experimental/string.view/string.view.cons/from_string1.fail.cpp
index 6ef4b9669bf4..b2ffa61c29d9 100644
--- a/test/std/experimental/string.view/string.view.cons/from_string1.fail.cpp
+++ b/test/std/experimental/string.view/string.view.cons/from_string1.fail.cpp
@@ -22,7 +22,7 @@ struct dummy_char_traits : public std::char_traits<char> {};
 int main () {
     using string_view = std::experimental::basic_string_view<char>;
     using string      = std::              basic_string     <char, dummy_char_traits>;
-    
+
     {
     string s{"QBCDE"};
     string_view sv1 ( s );
diff --git a/test/std/experimental/string.view/string.view.cons/from_string2.fail.cpp b/test/std/experimental/string.view/string.view.cons/from_string2.fail.cpp
index 6c77a3f99a2b..a14e131c85aa 100644
--- a/test/std/experimental/string.view/string.view.cons/from_string2.fail.cpp
+++ b/test/std/experimental/string.view/string.view.cons/from_string2.fail.cpp
@@ -22,7 +22,7 @@ struct dummy_char_traits : public std::char_traits<char> {};
 int main () {
     using string_view = std::experimental::basic_string_view<char, dummy_char_traits>;
     using string      = std::              basic_string     <char>;
-    
+
     {
     string s{"QBCDE"};
     string_view sv1 ( s );
diff --git a/test/std/experimental/string.view/string.view.iterators/begin.pass.cpp b/test/std/experimental/string.view/string.view.iterators/begin.pass.cpp
index 07f3b36e1d2b..8040b81d4efe 100644
--- a/test/std/experimental/string.view/string.view.iterators/begin.pass.cpp
+++ b/test/std/experimental/string.view/string.view.iterators/begin.pass.cpp
@@ -14,6 +14,8 @@
 #include <experimental/string_view>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <class S>
 void
 test(S s)
@@ -30,7 +32,7 @@ test(S s)
         assert(&*cb1 == &s[0]);
         assert( *cb2 ==  s[0]);
         assert(&*cb2 == &s[0]);
-        
+
     }
     assert(  b == cb1);
     assert(  b == cb2);
@@ -51,7 +53,7 @@ int main()
     test(wstring_view  ());
     test(string_view   ( "123"));
     test(wstring_view  (L"123"));
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test(u16string_view{u"123"});
     test(u32string_view{U"123"});
 #endif
@@ -62,7 +64,7 @@ int main()
     constexpr u16string_view u16sv {u"123", 3 };
     constexpr u32string_view u32sv {U"123", 3 };
     constexpr wstring_view     wsv {L"123", 3 };
-    
+
     static_assert (    *sv.begin() ==    sv[0], "" );
     static_assert ( *u16sv.begin() == u16sv[0], "" );
     static_assert ( *u32sv.begin() == u32sv[0], "" );
diff --git a/test/std/experimental/string.view/string.view.iterators/end.pass.cpp b/test/std/experimental/string.view/string.view.iterators/end.pass.cpp
index 2ed52b8de947..3a1091e9983c 100644
--- a/test/std/experimental/string.view/string.view.iterators/end.pass.cpp
+++ b/test/std/experimental/string.view/string.view.iterators/end.pass.cpp
@@ -14,6 +14,8 @@
 #include <experimental/string_view>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <class S>
 void
 test(S s)
@@ -35,7 +37,7 @@ test(S s)
         assert(ce1 != cs.begin());
         assert(ce2 !=  s.begin());
     }
-    
+
     assert(  e -  s.begin() == s.size());
     assert(ce1 - cs.begin() == cs.size());
     assert(ce2 - s.cbegin() == s.size());
@@ -59,7 +61,7 @@ int main()
     test(wstring_view  ());
     test(string_view   ( "123"));
     test(wstring_view  (L"123"));
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test(u16string_view{u"123"});
     test(u32string_view{U"123"});
 #endif
@@ -70,7 +72,7 @@ int main()
     constexpr u16string_view u16sv {u"123", 3 };
     constexpr u32string_view u32sv {U"123", 3 };
     constexpr wstring_view     wsv {L"123", 3 };
-    
+
     static_assert (    sv.begin() !=    sv.end(), "" );
     static_assert ( u16sv.begin() != u16sv.end(), "" );
     static_assert ( u32sv.begin() != u32sv.end(), "" );
diff --git a/test/std/experimental/string.view/string.view.iterators/rbegin.pass.cpp b/test/std/experimental/string.view/string.view.iterators/rbegin.pass.cpp
index 7d1c7003eaf4..068557e39863 100644
--- a/test/std/experimental/string.view/string.view.iterators/rbegin.pass.cpp
+++ b/test/std/experimental/string.view/string.view.iterators/rbegin.pass.cpp
@@ -14,6 +14,8 @@
 #include <experimental/string_view>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <class S>
 void
 test(S s)
@@ -31,7 +33,7 @@ test(S s)
         assert(&*cb1 == &s[last]);
         assert( *cb2 ==  s[last]);
         assert(&*cb2 == &s[last]);
-        
+
     }
     assert(  b == cb1);
     assert(  b == cb2);
@@ -52,7 +54,7 @@ int main()
     test(wstring_view  ());
     test(string_view   ( "123"));
     test(wstring_view  (L"123"));
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test(u16string_view{u"123"});
     test(u32string_view{U"123"});
 #endif
diff --git a/test/std/experimental/string.view/string.view.iterators/rend.pass.cpp b/test/std/experimental/string.view/string.view.iterators/rend.pass.cpp
index 57002f30518f..55e28a266948 100644
--- a/test/std/experimental/string.view/string.view.iterators/rend.pass.cpp
+++ b/test/std/experimental/string.view/string.view.iterators/rend.pass.cpp
@@ -14,6 +14,8 @@
 #include <experimental/string_view>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <class S>
 void
 test(S s)
@@ -35,7 +37,7 @@ test(S s)
         assert(ce1 != cs.rbegin());
         assert(ce2 !=  s.rbegin());
     }
-    
+
     assert(  e -  s.rbegin() == s.size());
     assert(ce1 - cs.rbegin() == cs.size());
     assert(ce2 - s.crbegin() == s.size());
@@ -52,14 +54,14 @@ int main()
     typedef std::experimental::u16string_view u16string_view;
     typedef std::experimental::u32string_view u32string_view;
     typedef std::experimental::wstring_view   wstring_view;
-    
+
     test(string_view   ());
     test(u16string_view());
     test(u32string_view());
     test(wstring_view  ());
     test(string_view   ( "123"));
     test(wstring_view  (L"123"));
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test(u16string_view{u"123"});
     test(u32string_view{U"123"});
 #endif
diff --git a/test/std/experimental/string.view/string.view.modifiers/clear.pass.cpp b/test/std/experimental/string.view/string.view.modifiers/clear.pass.cpp
index 6a9982e0d3a5..9a4891c8f259 100644
--- a/test/std/experimental/string.view/string.view.modifiers/clear.pass.cpp
+++ b/test/std/experimental/string.view/string.view.modifiers/clear.pass.cpp
@@ -15,6 +15,8 @@
 #include <experimental/string_view>
 #include <cassert>
 
+#include "test_macros.h"
+
 template<typename CharT>
 void test ( const CharT *s, size_t len ) {
     typedef std::experimental::basic_string_view<CharT> SV;
@@ -48,7 +50,7 @@ int main () {
     test ( L"a", 1 );
     test ( L"", 0 );
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test ( u"ABCDE", 5 );
     test ( u"a", 1 );
     test ( u"", 0 );
diff --git a/test/std/experimental/string.view/string.view.modifiers/remove_prefix.pass.cpp b/test/std/experimental/string.view/string.view.modifiers/remove_prefix.pass.cpp
index 0a2dd6d9329c..4a31486afaa0 100644
--- a/test/std/experimental/string.view/string.view.modifiers/remove_prefix.pass.cpp
+++ b/test/std/experimental/string.view/string.view.modifiers/remove_prefix.pass.cpp
@@ -16,6 +16,8 @@
 #include <cassert>
 #include <iostream>
 
+#include "test_macros.h"
+
 template<typename CharT>
 void test ( const CharT *s, size_t len ) {
     typedef std::experimental::basic_string_view<CharT> SV;
@@ -30,10 +32,10 @@ void test ( const CharT *s, size_t len ) {
         assert ( sv1.data() == (s + 1));
         sv1.remove_prefix ( len - 1 );
     }
-    
+
     assert ( sv1.size() == 0 );
     sv1.remove_prefix ( 0 );
-    assert ( sv1.size() == 0 ); 
+    assert ( sv1.size() == 0 );
     }
 }
 
@@ -55,7 +57,7 @@ int main () {
     test ( L"a", 1 );
     test ( L"", 0 );
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test ( u"ABCDE", 5 );
     test ( u"a", 1 );
     test ( u"", 0 );
diff --git a/test/std/experimental/string.view/string.view.modifiers/remove_suffix.pass.cpp b/test/std/experimental/string.view/string.view.modifiers/remove_suffix.pass.cpp
index 9dd59882cce6..9ddc6de84bf3 100644
--- a/test/std/experimental/string.view/string.view.modifiers/remove_suffix.pass.cpp
+++ b/test/std/experimental/string.view/string.view.modifiers/remove_suffix.pass.cpp
@@ -15,6 +15,8 @@
 #include <experimental/string_view>
 #include <cassert>
 
+#include "test_macros.h"
+
 template<typename CharT>
 void test ( const CharT *s, size_t len ) {
     typedef std::experimental::basic_string_view<CharT> SV;
@@ -29,10 +31,10 @@ void test ( const CharT *s, size_t len ) {
         assert ( sv1.data() == s);
         sv1.remove_suffix ( len - 1 );
         }
-        
+
     assert ( sv1.size() == 0 );
     sv1.remove_suffix ( 0 );
-    assert ( sv1.size() == 0 ); 
+    assert ( sv1.size() == 0 );
     }
 
 }
@@ -55,7 +57,7 @@ int main () {
     test ( L"a", 1 );
     test ( L"", 0 );
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test ( u"ABCDE", 5 );
     test ( u"a", 1 );
     test ( u"", 0 );
diff --git a/test/std/experimental/string.view/string.view.modifiers/swap.pass.cpp b/test/std/experimental/string.view/string.view.modifiers/swap.pass.cpp
index cacb8ed40b88..d747def8549e 100644
--- a/test/std/experimental/string.view/string.view.modifiers/swap.pass.cpp
+++ b/test/std/experimental/string.view/string.view.modifiers/swap.pass.cpp
@@ -15,13 +15,15 @@
 #include <experimental/string_view>
 #include <cassert>
 
+#include "test_macros.h"
+
 template<typename CharT>
 void test ( const CharT *s, size_t len ) {
     typedef std::experimental::basic_string_view<CharT> SV;
     {
     SV sv1(s);
     SV sv2;
-    
+
     assert ( sv1.size() == len );
     assert ( sv1.data() == s );
     assert ( sv2.size() == 0 );
@@ -54,7 +56,7 @@ int main () {
     test ( L"a", 1 );
     test ( L"", 0 );
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test ( u"ABCDE", 5 );
     test ( u"a", 1 );
     test ( u"", 0 );
diff --git a/test/std/experimental/string.view/string.view.nonmem/quoted.pass.cpp b/test/std/experimental/string.view/string.view.nonmem/quoted.pass.cpp
index c86e9619f193..6ba03212d42b 100644
--- a/test/std/experimental/string.view/string.view.nonmem/quoted.pass.cpp
+++ b/test/std/experimental/string.view/string.view.nonmem/quoted.pass.cpp
@@ -103,7 +103,7 @@ void round_trip ( const wchar_t *p ) {
     assert ( s == sv );
     assert ( skippingws == is_skipws ( &ss ));
     }
-    
+
 
 void round_trip_ws ( const wchar_t *p ) {
     std::wstringstream ss;
@@ -165,31 +165,31 @@ int main()
     round_trip_ws (  "" );
     round_trip_d  (  "", 'q' );
     round_trip_e  (  "", 'q' );
-    
+
     round_trip    ( L"" );
     round_trip_ws ( L"" );
     round_trip_d  ( L"", 'q' );
     round_trip_e  ( L"", 'q' );
-    
+
     round_trip    (  "Hi" );
     round_trip_ws (  "Hi" );
     round_trip_d  (  "Hi", '!' );
     round_trip_e  (  "Hi", '!' );
     assert ( quote ( "Hi", '!' ) == "!Hi!" );
     assert ( quote ( "Hi!", '!' ) == R"(!Hi\!!)" );
-    
+
     round_trip    ( L"Hi" );
     round_trip_ws ( L"Hi" );
     round_trip_d  ( L"Hi", '!' );
     round_trip_e  ( L"Hi", '!' );
     assert ( quote ( L"Hi", '!' )  == L"!Hi!" );
     assert ( quote ( L"Hi!", '!' ) == LR"(!Hi\!!)" );
-    
+
     round_trip    (  "Hi Mom" );
     round_trip_ws (  "Hi Mom" );
     round_trip    ( L"Hi Mom" );
     round_trip_ws ( L"Hi Mom" );
-    
+
     assert ( quote (  "" )  ==  "\"\"" );
     assert ( quote ( L"" )  == L"\"\"" );
     assert ( quote (  "a" ) ==  "\"a\"" );
@@ -198,7 +198,7 @@ int main()
 //  missing end quote - must not hang
     assert ( unquote (  "\"abc" ) ==  "abc" );
     assert ( unquote ( L"\"abc" ) == L"abc" );
-    
+
     assert ( unquote (  "abc" ) == "abc" ); // no delimiter
     assert ( unquote ( L"abc" ) == L"abc" ); // no delimiter
     assert ( unquote (  "abc def" ) ==  "abc" ); // no delimiter
diff --git a/test/std/experimental/string.view/string.view.ops/basic_string.pass.cpp b/test/std/experimental/string.view/string.view.ops/basic_string.pass.cpp
index 29f5064d81dc..a29bb15f5ac9 100644
--- a/test/std/experimental/string.view/string.view.ops/basic_string.pass.cpp
+++ b/test/std/experimental/string.view/string.view.ops/basic_string.pass.cpp
@@ -16,11 +16,13 @@
 #include <experimental/string_view>
 #include <cassert>
 
+#include "test_macros.h"
+
 template<typename CharT>
 void test ( const CharT *s ) {
     typedef std::experimental::basic_string_view<CharT> string_view_t;
     typedef std::basic_string<CharT> string_t;
-    
+
     {
     string_view_t sv1 ( s );
     string_t      str = (string_t) sv1;
@@ -49,7 +51,7 @@ int main () {
     test ( L"a" );
     test ( L"" );
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test ( u"ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE" );
     test ( u"ABCDE" );
     test ( u"a" );
diff --git a/test/std/experimental/string.view/string.view.ops/compare.pointer.pass.cpp b/test/std/experimental/string.view/string.view.ops/compare.pointer.pass.cpp
index 6ccec9b3729a..583395451fd4 100644
--- a/test/std/experimental/string.view/string.view.ops/compare.pointer.pass.cpp
+++ b/test/std/experimental/string.view/string.view.ops/compare.pointer.pass.cpp
@@ -72,7 +72,7 @@ int main()
     test(L"abcdefghijklmnopqrst", L"abcdefghijklmnopqrst", 0);
     }
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     test(U"", U"", 0);
     test(U"", U"abcde", -5);
diff --git a/test/std/experimental/string.view/string.view.ops/compare.pointer_size.pass.cpp b/test/std/experimental/string.view/string.view.ops/compare.pointer_size.pass.cpp
index 7ccbd528c7fc..cfe35fcb4719 100644
--- a/test/std/experimental/string.view/string.view.ops/compare.pointer_size.pass.cpp
+++ b/test/std/experimental/string.view/string.view.ops/compare.pointer_size.pass.cpp
@@ -7,7 +7,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <string_view>
 
 // constexpr int compare(size_type pos1, size_type n1, const charT* s) const;
@@ -15,18 +14,27 @@
 #include <experimental/string_view>
 #include <cassert>
 
+#include "test_macros.h"
 #include "constexpr_char_traits.hpp"
 
 int sign ( int x ) { return x > 0 ? 1 : ( x < 0 ? -1 : 0 ); }
 
 template<typename CharT>
-void test1 ( std::experimental::basic_string_view<CharT> sv1, 
+void test1 ( std::experimental::basic_string_view<CharT> sv1,
              size_t pos1, size_t n1, const CharT *s, int expected ) {
-    try {
+    if (pos1 > sv1.size()) {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+        try {
+            sv1.compare(pos1, n1, s);
+            assert(false);
+        } catch (const std::out_of_range&) {
+        } catch (...) {
+            assert(false);
+        }
+#endif
+    } else {
         assert(sign(sv1.compare(pos1, n1, s)) == sign(expected));
-        assert(pos1 <= sv1.size());
     }
-    catch (const std::out_of_range&) { assert(pos1 > sv1.size()); }
 }
 
 template<typename CharT>
@@ -391,7 +399,7 @@ int main()
     test(L"abcdefghijklmnopqrst", 0, -1, L"abcdefghijklmnopqrst", 0);
     }
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     test(U"", 0, 0, U"", 0);
     test(U"", 0, 0, U"abcde", -5);
@@ -410,7 +418,7 @@ int main()
     test(U"abcdefghijklmnopqrst", 0, 12, U"abcdefghij", 10);
     test(U"abcdefghijklmnopqrst", 0, -1, U"abcdefghijklmnopqrst", 0);
     }
- 
+
     {
     test(u"", 0, 0, u"", 0);
     test(u"", 0, 0, u"abcde", -5);
@@ -431,7 +439,7 @@ int main()
     }
 #endif
 
-#if _LIBCPP_STD_VER > 11
+#if TEST_STD_VER > 11
     {
     typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
     constexpr SV  sv1;
diff --git a/test/std/experimental/string.view/string.view.ops/compare.size_size_sv.pass.cpp b/test/std/experimental/string.view/string.view.ops/compare.size_size_sv.pass.cpp
index 244de9eb5104..2684d903405e 100644
--- a/test/std/experimental/string.view/string.view.ops/compare.size_size_sv.pass.cpp
+++ b/test/std/experimental/string.view/string.view.ops/compare.size_size_sv.pass.cpp
@@ -7,8 +7,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-
-// XFAIL: libcpp-no-exceptions
 // <string_view>
 
 // constexpr int compare(size_type pos1, size_type n1, basic_string_view str) const;
@@ -16,6 +14,7 @@
 #include <experimental/string_view>
 #include <cassert>
 
+#include "test_macros.h"
 #include "constexpr_char_traits.hpp"
 
 int sign ( int x ) { return x > 0 ? 1 : ( x < 0 ? -1 : 0 ); }
@@ -24,19 +23,25 @@ template<typename CharT>
 void test1 ( std::experimental::basic_string_view<CharT> sv1, size_t pos1, size_t n1,
             std::experimental::basic_string_view<CharT> sv2, int expected ) {
 
-    try
-    {
+    if (pos1 > sv1.size()) {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+        try {
+            sv1.compare(pos1, n1, sv2);
+            assert(false);
+        } catch (const std::out_of_range&) {
+        } catch (...) {
+            assert(false);
+        }
+#endif
+    } else {
         assert ( sign( sv1.compare(pos1, n1, sv2)) == sign(expected));
-        assert(pos1 <= sv1.size());
     }
-    catch (const std::out_of_range&) { assert(pos1 > sv1.size()); }
 }
 
 
 template<typename CharT>
 void test ( const CharT *s1, size_t pos1, size_t n1, const CharT  *s2, int expected ) {
     typedef std::experimental::basic_string_view<CharT> string_view_t;
-    
     string_view_t sv1 ( s1 );
     string_view_t sv2 ( s2 );
     test1(sv1, pos1, n1, sv2, expected);
@@ -355,7 +360,7 @@ int main () {
     test0();
     test1();
     test2();
-    
+
     {
     test("abcde", 5, 1, "", 0);
     test("abcde", 2, 4, "", 3);
@@ -370,7 +375,7 @@ int main () {
     test(L"ABCde", 2, 4, L"abcde", -1);
     }
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     test(u"abcde", 5, 1, u"", 0);
     test(u"abcde", 2, 4, u"", 3);
@@ -386,7 +391,7 @@ int main () {
     }
 #endif
 
-#if _LIBCPP_STD_VER > 11
+#if TEST_STD_VER > 11
     {
     typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
     constexpr SV  sv1 { "abcde", 5 };
diff --git a/test/std/experimental/string.view/string.view.ops/compare.size_size_sv_pointer_size.pass.cpp b/test/std/experimental/string.view/string.view.ops/compare.size_size_sv_pointer_size.pass.cpp
index 1c3bc089a656..69de6335fb5c 100644
--- a/test/std/experimental/string.view/string.view.ops/compare.size_size_sv_pointer_size.pass.cpp
+++ b/test/std/experimental/string.view/string.view.ops/compare.size_size_sv_pointer_size.pass.cpp
@@ -7,8 +7,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-
-// XFAIL: libcpp-no-exceptions
 // <string_view>
 
 // constexpr int compare(size_type pos1, size_type n1,
@@ -17,6 +15,7 @@
 #include <experimental/string_view>
 #include <cassert>
 
+#include "test_macros.h"
 #include "constexpr_char_traits.hpp"
 
 int sign ( int x ) { return x > 0 ? 1 : ( x < 0 ? -1 : 0 ); }
@@ -25,22 +24,29 @@ template<typename CharT>
 void test1 ( std::experimental::basic_string_view<CharT> sv1, size_t pos1, size_t n1,
              const CharT *s2, size_t n2,
              int expected ) {
-
-    try
-    {
-        assert ( sign( sv1.compare(pos1, n1, s2, n2)) == sign(expected));
-        assert(pos1 <= sv1.size());
+    if (pos1 > sv1.size()) {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+        try {
+            sv1.compare(pos1, n1, s2, n2);
+            assert(false);
+        } catch (const std::out_of_range&) {
+            return;
+        } catch (...) {
+            assert(false);
+        }
+#endif
+    } else {
+        assert(sign(sv1.compare(pos1, n1, s2, n2)) == sign(expected));
     }
-    catch (const std::out_of_range&) { assert(pos1 > sv1.size()); }
+
 }
 
 
 template<typename CharT>
-void test ( const CharT *s1, size_t pos1, size_t n1, 
-            const CharT *s2, size_t n2, 
+void test ( const CharT *s1, size_t pos1, size_t n1,
+            const CharT *s2, size_t n2,
             int expected ) {
     typedef std::experimental::basic_string_view<CharT> string_view_t;
-    
     string_view_t sv1 ( s1 );
     test1 (sv1, pos1, n1, s2, n2, expected);
 }
@@ -1302,7 +1308,7 @@ int main () {
     test9();
     test10();
     test11();
-    
+
     {
     test("", 0, 0, "abcde", 0, 0);
     test("", 0, 0, "abcde", 1, -1);
@@ -1319,7 +1325,7 @@ int main () {
     test(L"abcdefghijklmnopqrst", 10, 0, L"abcdefghij", 10, -10);
     }
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     test(U"", 0, 0, U"abcde", 0, 0);
     test(U"", 0, 0, U"abcde", 1, -1);
@@ -1337,7 +1343,7 @@ int main () {
     }
 #endif
 
-#if _LIBCPP_STD_VER > 11
+#if TEST_STD_VER > 11
     {
     typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
     constexpr SV  sv1;
diff --git a/test/std/experimental/string.view/string.view.ops/compare.size_size_sv_size_size.pass.cpp b/test/std/experimental/string.view/string.view.ops/compare.size_size_sv_size_size.pass.cpp
index c7a6f1e1eb66..5d5ccc5b5d59 100644
--- a/test/std/experimental/string.view/string.view.ops/compare.size_size_sv_size_size.pass.cpp
+++ b/test/std/experimental/string.view/string.view.ops/compare.size_size_sv_size_size.pass.cpp
@@ -7,8 +7,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-
-// XFAIL: libcpp-no-exceptions
 // <string_view>
 
 // constexpr int compare(size_type pos1, size_type n1, basic_string_view str,
@@ -17,6 +15,7 @@
 #include <experimental/string_view>
 #include <cassert>
 
+#include "test_macros.h"
 #include "constexpr_char_traits.hpp"
 
 int sign ( int x ) { return x > 0 ? 1 : ( x < 0 ? -1 : 0 ); }
@@ -26,22 +25,28 @@ void test1 ( std::experimental::basic_string_view<CharT> sv1, size_t pos1, size_
              std::experimental::basic_string_view<CharT> sv2, size_t pos2, size_t n2,
              int expected ) {
 
-    try
-    {
-        assert ( sign( sv1.compare(pos1, n1, sv2, pos2, n2)) == sign(expected));
-        assert(pos1 <= sv1.size());
-        assert(pos2 <= sv2.size());
+    if (pos1 > sv1.size() || pos2 > sv2.size()) {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+        try {
+            sv1.compare(pos1, n1, sv2, pos2, n2);
+            assert(false);
+        } catch (const std::out_of_range&) {
+        } catch (...) {
+            assert(false);
+        }
+#endif
+    } else {
+        assert (sign( sv1.compare(pos1, n1, sv2, pos2, n2)) == sign(expected));
     }
-    catch (const std::out_of_range&) { assert(pos1 > sv1.size() || pos2 > sv2.size()); }
 }
 
 
 template<typename CharT>
-void test ( const CharT *s1, size_t pos1, size_t n1, 
-            const CharT *s2, size_t pos2, size_t n2, 
+void test ( const CharT *s1, size_t pos1, size_t n1,
+            const CharT *s2, size_t pos2, size_t n2,
             int expected ) {
     typedef std::experimental::basic_string_view<CharT> string_view_t;
-    
+
     string_view_t sv1 ( s1 );
     string_view_t sv2 ( s2 );
     test1(sv1, pos1, n1, sv2, pos2, n2, expected);
@@ -5801,7 +5806,7 @@ int main () {
     test53();
     test54();
 
-    
+
     {
     test("abcde", 5, 1, "", 0, 0, 0);
     test("abcde", 2, 4, "", 0, 0, 3);
@@ -5816,7 +5821,7 @@ int main () {
     test(L"ABCde", 2, 4, L"abcde", 2, 4, -1);
     }
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     test(u"abcde", 5, 1, u"", 0, 0, 0);
     test(u"abcde", 2, 4, u"", 0, 0, 3);
@@ -5832,7 +5837,7 @@ int main () {
     }
 #endif
 
-#if _LIBCPP_STD_VER > 11
+#if TEST_STD_VER > 11
     {
     typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
     constexpr SV  sv1 { "abcde", 5 };
diff --git a/test/std/experimental/string.view/string.view.ops/compare.sv.pass.cpp b/test/std/experimental/string.view/string.view.ops/compare.sv.pass.cpp
index 3f686697ba40..4364ab063543 100644
--- a/test/std/experimental/string.view/string.view.ops/compare.sv.pass.cpp
+++ b/test/std/experimental/string.view/string.view.ops/compare.sv.pass.cpp
@@ -19,7 +19,7 @@
 int sign ( int x ) { return x > 0 ? 1 : ( x < 0 ? -1 : 0 ); }
 
 template<typename CharT>
-void test1 ( std::experimental::basic_string_view<CharT> sv1, 
+void test1 ( std::experimental::basic_string_view<CharT> sv1,
             std::experimental::basic_string_view<CharT> sv2, int expected ) {
     assert ( sign( sv1.compare(sv2)) == sign(expected));
 }
@@ -28,7 +28,7 @@ void test1 ( std::experimental::basic_string_view<CharT> sv1,
 template<typename CharT>
 void test ( const CharT *s1, const CharT  *s2, int expected ) {
     typedef std::experimental::basic_string_view<CharT> string_view_t;
-    
+
     string_view_t sv1 ( s1 );
     string_view_t sv2 ( s2 );
     test1(sv1, sv2, expected);
@@ -70,7 +70,7 @@ int main () {
     test(L"abcdefghijklmnopqrst", L"abcdefghij", 10);
     test(L"abcdefghijklmnopqrst", L"abcdefghijklmnopqrst", 0);
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test(u"",                     u"", 0);
     test(u"",                     u"abcde", -5);
     test(u"",                     u"abcdefghij", -10);
@@ -105,7 +105,7 @@ int main () {
     test(U"abcdefghijklmnopqrst", U"abcdefghij", 10);
     test(U"abcdefghijklmnopqrst", U"abcdefghijklmnopqrst", 0);
 #endif
-    
+
 #if _LIBCPP_STD_VER > 11
     {
     typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
@@ -117,5 +117,5 @@ int main () {
     static_assert ( sv3.compare(sv2)  > 0, "" );
     static_assert ( sv2.compare(sv3)  < 0, "" );
     }
-#endif    
+#endif
 }
diff --git a/test/std/experimental/string.view/string.view.ops/copy.pass.cpp b/test/std/experimental/string.view/string.view.ops/copy.pass.cpp
index 0e4eb9e50bb0..0acd5bda4011 100644
--- a/test/std/experimental/string.view/string.view.ops/copy.pass.cpp
+++ b/test/std/experimental/string.view/string.view.ops/copy.pass.cpp
@@ -7,8 +7,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-
-// XFAIL: libcpp-no-exceptions
 // <string_view>
 
 // size_type copy(charT* s, size_type n, size_type pos = 0) const;
@@ -23,30 +21,40 @@
 #include <experimental/string_view>
 #include <cassert>
 
+#include "test_macros.h"
+
 template<typename CharT>
 void test1 ( std::experimental::basic_string_view<CharT> sv, size_t n, size_t pos ) {
     const size_t rlen = std::min ( n, sv.size() - pos );
 
     CharT *dest1 = new CharT [rlen + 1];    dest1[rlen] = 0;
     CharT *dest2 = new CharT [rlen + 1];    dest2[rlen] = 0;
-    
-    try {
+
+    if (pos > sv.size()) {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+        try {
+            sv.copy(dest1, n, pos);
+            assert(false);
+        } catch (const std::out_of_range&) {
+        } catch (...) {
+            assert(false);
+        }
+#endif
+    } else {
         sv.copy(dest1, n, pos);
         std::copy_n(sv.begin() + pos, rlen, dest2);
-
         for ( size_t i = 0; i <= rlen; ++i )
             assert ( dest1[i] == dest2[i] );
-        }
-    catch ( const std::out_of_range & ) { assert ( pos > sv.size()); }
+    }
     delete [] dest1;
-    delete [] dest2;    
+    delete [] dest2;
 }
 
 
 template<typename CharT>
 void test ( const CharT *s ) {
     typedef std::experimental::basic_string_view<CharT> string_view_t;
-    
+
     string_view_t sv1 ( s );
 
     test1(sv1,  0, 0);
@@ -54,7 +62,7 @@ void test ( const CharT *s ) {
     test1(sv1, 20, 0);
     test1(sv1, sv1.size(), 0);
     test1(sv1, 20, string_view_t::npos);
-    
+
     test1(sv1,   0, 3);
     test1(sv1,   2, 3);
     test1(sv1, 100, 3);
@@ -79,7 +87,7 @@ int main () {
     test ( L"a" );
     test ( L"" );
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test ( u"ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE" );
     test ( u"ABCDE" );
     test ( u"a" );
diff --git a/test/std/experimental/string.view/string.view.ops/substr.pass.cpp b/test/std/experimental/string.view/string.view.ops/substr.pass.cpp
index c80e90a04788..a651010d4b27 100644
--- a/test/std/experimental/string.view/string.view.ops/substr.pass.cpp
+++ b/test/std/experimental/string.view/string.view.ops/substr.pass.cpp
@@ -7,8 +7,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-
-// XFAIL: libcpp-no-exceptions
 // <string_view>
 
 // constexpr basic_string_view substr(size_type pos = 0, size_type n = npos) const;
@@ -20,30 +18,42 @@
 #include <experimental/string_view>
 #include <cassert>
 
+#include "test_macros.h"
+
 template<typename CharT>
 void test1 ( std::experimental::basic_string_view<CharT> sv, size_t n, size_t pos ) {
-    try {
+    if (pos > sv.size()) {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+        try {
+            std::experimental::basic_string_view<CharT> sv1 = sv.substr(pos, n);
+            assert(false);
+        } catch (const std::out_of_range&) {
+            return;
+        } catch (...) {
+            assert(false);
+        }
+#endif
+    } else {
         std::experimental::basic_string_view<CharT> sv1 = sv.substr(pos, n);
         const size_t rlen = std::min ( n, sv.size() - pos );
         assert ( sv1.size() == rlen );
         for ( size_t i = 0; i <= rlen; ++i )
             assert ( sv[pos+i] == sv1[i] );
-        }
-    catch ( const std::out_of_range & ) { assert ( pos > sv.size()); }
+    }
 }
 
 
 template<typename CharT>
 void test ( const CharT *s ) {
     typedef std::experimental::basic_string_view<CharT> string_view_t;
-    
+
     string_view_t sv1 ( s );
 
     test1(sv1,  0, 0);
     test1(sv1,  1, 0);
     test1(sv1, 20, 0);
     test1(sv1, sv1.size(), 0);
-    
+
     test1(sv1,   0, 3);
     test1(sv1,   2, 3);
     test1(sv1, 100, 3);
@@ -68,7 +78,7 @@ int main () {
     test ( L"a" );
     test ( L"" );
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test ( u"ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE" );
     test ( u"ABCDE" );
     test ( u"a" );
@@ -79,8 +89,8 @@ int main () {
     test ( U"a" );
     test ( U"" );
 #endif
-    
-#if _LIBCPP_STD_VER > 11
+
+#if TEST_STD_VER > 11
     {
     constexpr std::experimental::string_view sv1 { "ABCDE", 5 };
 
@@ -91,7 +101,7 @@ int main () {
     static_assert ( sv2[1] == 'B', "" );
     static_assert ( sv2[2] == 'C', "" );
     }
-    
+
     {
     constexpr std::experimental::string_view sv2 = sv1.substr ( 3, 0 );
     static_assert ( sv2.size() == 0, "" );
diff --git a/test/std/experimental/string.view/string.view.ops/to_string.pass.cpp b/test/std/experimental/string.view/string.view.ops/to_string.pass.cpp
index a180ab257bf5..a32a2684c548 100644
--- a/test/std/experimental/string.view/string.view.ops/to_string.pass.cpp
+++ b/test/std/experimental/string.view/string.view.ops/to_string.pass.cpp
@@ -26,11 +26,11 @@ void test ( const CharT *s ) {
     {
     const std::experimental::basic_string_view<CharT> sv1 ( s );
     String                                            str1 = (String) sv1;
-    
+
     assert ( sv1.size() == str1.size ());
     assert ( std::char_traits<CharT>::compare ( sv1.data(), str1.data(),  sv1.size()) == 0 );
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     auto str2 = sv1.to_string(min_allocator<CharT>());
     assert ( sv1.size() == str2.size ());
     assert ( std::char_traits<CharT>::compare ( sv1.data(), str2.data(), sv1.size()) == 0 );
@@ -44,7 +44,7 @@ void test ( const CharT *s ) {
     assert ( sv1.size() == 0);
     assert ( sv1.size() == str1.size ());
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     auto str2 = sv1.to_string(min_allocator<CharT>());
     assert ( sv1.size() == str2.size ());
 #endif
@@ -62,7 +62,7 @@ int main () {
     test ( L"a" );
     test ( L"" );
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test ( u"ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE" );
     test ( u"ABCDE" );
     test ( u"a" );
diff --git a/test/std/experimental/utilities/meta/meta.type.synop/includes.pass.cpp b/test/std/experimental/utilities/meta/meta.type.synop/includes.pass.cpp
index 2c90dd641813..ddc82cb5482f 100644
--- a/test/std/experimental/utilities/meta/meta.type.synop/includes.pass.cpp
+++ b/test/std/experimental/utilities/meta/meta.type.synop/includes.pass.cpp
@@ -7,14 +7,13 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <experimental/type_traits>
 
 #include <experimental/type_traits>
 
-#if _LIBCPP_STD_VER > 11
-# ifndef _LIBCPP_TYPE_TRAITS
-#   error "<experimental/type_traits> must include <type_traits>"
-# endif
+#ifndef _LIBCPP_TYPE_TRAITS
+#  error "<experimental/type_traits> must include <type_traits>"
 #endif
 
 int main()
diff --git a/test/std/experimental/utilities/meta/meta.type.synop/meta.rel.pass.cpp b/test/std/experimental/utilities/meta/meta.type.synop/meta.rel.pass.cpp
index 96af4b676181..8edc917303ac 100644
--- a/test/std/experimental/utilities/meta/meta.type.synop/meta.rel.pass.cpp
+++ b/test/std/experimental/utilities/meta/meta.type.synop/meta.rel.pass.cpp
@@ -7,12 +7,11 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <experimental/type_traits>
 
 #include <experimental/type_traits>
 
-#if _LIBCPP_STD_VER > 11
-
 namespace ex = std::experimental;
 
 struct base_type {};
@@ -60,6 +59,4 @@ int main()
         static_assert(ex::is_convertible_v<T, U> == std::is_convertible<T, U>::value, "");
     }
 }
-#else /* _LIBCPP_STD_VER <= 11 */
-int main() {}
-#endif /* _LIBCPP_STD_VER > 11 */
+
diff --git a/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.cat.pass.cpp b/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.cat.pass.cpp
index 2d1e706f67d2..a4a91c136927 100644
--- a/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.cat.pass.cpp
+++ b/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.cat.pass.cpp
@@ -7,12 +7,11 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <experimental/type_traits>
 
 #include <experimental/type_traits>
 
-#if _LIBCPP_STD_VER > 11
-
 namespace ex = std::experimental;
 
 struct class_type {};
@@ -176,6 +175,4 @@ int main()
         static_assert(ex::is_function_v<T> == std::is_function<T>::value, "");
     }
 }
-#else /* _LIBCPP_STD_VER <= 11 */
-int main() {}
-#endif /* _LIBCPP_STD_VER > 11 */
+
diff --git a/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.comp.pass.cpp b/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.comp.pass.cpp
index 814f450f4e07..b3927b120951 100644
--- a/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.comp.pass.cpp
+++ b/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.comp.pass.cpp
@@ -7,12 +7,11 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <experimental/type_traits>
 
 #include <experimental/type_traits>
 
-#if _LIBCPP_STD_VER > 11
-
 namespace ex = std::experimental;
 
 struct class_type {};
@@ -97,6 +96,4 @@ int main()
         static_assert(ex::is_member_pointer_v<T> == std::is_member_pointer<T>::value, "");
     }
 }
-#else /* _LIBCPP_STD_VER <= 11 */
-int main() {}
-#endif /* _LIBCPP_STD_VER > 11 */
+
diff --git a/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.prop.pass.cpp b/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.prop.pass.cpp
index 41cb27fced37..e267c6833ab9 100644
--- a/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.prop.pass.cpp
+++ b/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.prop.pass.cpp
@@ -7,12 +7,11 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <experimental/type_traits>
 
 #include <experimental/type_traits>
 
-#if _LIBCPP_STD_VER > 11
-
 namespace ex = std::experimental;
 
 struct non_literal_type { non_literal_type() {} };
@@ -484,6 +483,4 @@ int main()
         static_assert(ex::has_virtual_destructor_v<T> == std::has_virtual_destructor<T>::value, "");
     }
 }
-#else /* _LIBCPP_STD_VER <= 11 */
-int main() {}
-#endif /* _LIBCPP_STD_VER > 11 */
+
diff --git a/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.prop.query.pass.cpp b/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.prop.query.pass.cpp
index aedd369e5ac8..f91667da523c 100644
--- a/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.prop.query.pass.cpp
+++ b/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.prop.query.pass.cpp
@@ -7,12 +7,11 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <experimental/type_traits>
 
 #include <experimental/type_traits>
 
-#if _LIBCPP_STD_VER > 11
-
 namespace ex = std::experimental;
 
 int main()
@@ -61,6 +60,3 @@ int main()
         static_assert(ex::extent_v<T, 0> == std::extent<T, 0>::value, "");
     }
 }
-#else /* _LIBCPP_STD_VER <= 11 */
-int main() {}
-#endif /* _LIBCPP_STD_VER > 11 */
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign.pass.cpp
new file mode 100644
index 000000000000..33826383d127
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign.pass.cpp
@@ -0,0 +1,24 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// template <class U> propagate_const& propagate_const::operator=(const propagate_const<U>&)=delete;
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <type_traits>
+
+using std::experimental::propagate_const;
+
+typedef propagate_const<X> P;
+
+int main() { static_assert(!std::is_assignable<P, const P &>::value, ""); }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_element_type.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_element_type.pass.cpp
new file mode 100644
index 000000000000..6de6c63d6104
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_element_type.pass.cpp
@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// template <class U> propagate_const& propagate_const::operator=(U&&);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+int main() {
+
+  typedef propagate_const<CopyConstructibleFromX> PY;
+
+  X x1(1);
+  PY p(2);
+
+  assert(*p==2);
+
+  p = x1;
+
+  assert(*p==1);
+}
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_propagate_const.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_propagate_const.pass.cpp
new file mode 100644
index 000000000000..ae6ef08d3cf0
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_propagate_const.pass.cpp
@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// template <class U> constexpr propagate_const& operator=(U&& u); // won't bind to propagate_const
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <type_traits>
+
+using std::experimental::propagate_const;
+
+typedef propagate_const<X> PX;
+typedef propagate_const<CopyConstructibleFromX> PY;
+
+int main() { static_assert(!std::is_assignable<PY, const PX &>::value, ""); }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_element_type.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_element_type.pass.cpp
new file mode 100644
index 000000000000..e4051325f1c1
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_element_type.pass.cpp
@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// template <class U> propagate_const& propagate_const::operator=(U&&);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+int main() {
+
+  typedef propagate_const<X> P;
+
+  X x1(1);
+  P p(2);
+
+  assert(*p==2);
+
+  p = x1;
+
+  assert(*p==1);
+}
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign.pass.cpp
new file mode 100644
index 000000000000..b112b078d821
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign.pass.cpp
@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// template <class U> propagate_const& propagate_const::operator=(propagate_const<U>&&);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+int main() {
+
+  typedef propagate_const<X> P;
+
+  P p1(1);
+  P p2(2);
+
+  p2=std::move(p1);
+
+  assert(*p2==1);
+}
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible.pass.cpp
new file mode 100644
index 000000000000..282f0aee6153
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible.pass.cpp
@@ -0,0 +1,33 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// template <class U> propagate_const& propagate_const::operator=(propagate_const<U>&&);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+int main() {
+
+  typedef propagate_const<X> PX;
+  typedef propagate_const<MoveConstructibleFromX> PY;
+
+  PX px2(2);
+  PY py1(1);
+
+  py1=std::move(px2);
+
+  assert(*py1==2);
+}
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible_propagate_const.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible_propagate_const.pass.cpp
new file mode 100644
index 000000000000..743fc8eacbfa
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible_propagate_const.pass.cpp
@@ -0,0 +1,33 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// template <class U> constexpr propagate_const& operator=(propagate_const<_Up>&& pu);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+int main() {
+
+  typedef propagate_const<X> PX;
+  typedef propagate_const<MoveConstructibleFromX> PY;
+
+  PX px2(2);
+  PY py1(1);
+
+  py1=std::move(px2);
+
+  assert(*py1==2);
+}
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.explicit.ctor.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.explicit.ctor.pass.cpp
new file mode 100644
index 000000000000..10b0dd896280
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.explicit.ctor.pass.cpp
@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// template <class U> constexpr propagate_const& operator=(propagate_const<_Up>&& pu);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <type_traits>
+
+using std::experimental::propagate_const;
+
+typedef propagate_const<ExplicitCopyConstructibleFromX> P;
+
+int main() {
+  static_assert(!std::is_convertible<P, X>::value, "");
+  static_assert(std::is_constructible<P, X>::value, "");
+}
+
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.non-explicit.ctor.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.non-explicit.ctor.pass.cpp
new file mode 100644
index 000000000000..8ba5261de5e3
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.non-explicit.ctor.pass.cpp
@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// template <class U> constexpr propagate_const(propagate_const<_Up>&& pu);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+typedef propagate_const<CopyConstructibleFromX> P;
+
+void f(const P& p)
+{
+  assert(*p==2);
+}
+
+int main() {
+  f(X(2));
+}
+
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.copy_ctor.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.copy_ctor.pass.cpp
new file mode 100644
index 000000000000..ca65f3c47fff
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.copy_ctor.pass.cpp
@@ -0,0 +1,26 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// template <class U> constexpr propagate_const& operator(propagate_const<_Up>&& pu);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <type_traits>
+
+using std::experimental::propagate_const;
+
+typedef propagate_const<X> PX;
+typedef propagate_const<CopyConstructibleFromX> PY;
+
+int main() { static_assert(!std::is_constructible<PX, PY>::value, ""); }
+
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.explicit.move_ctor.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.explicit.move_ctor.pass.cpp
new file mode 100644
index 000000000000..b021cbd5e5e1
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.explicit.move_ctor.pass.cpp
@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// template <class U> constexpr propagate_const(propagate_const<_Up>&& pu);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <type_traits>
+
+using std::experimental::propagate_const;
+
+typedef propagate_const<X> PX;
+typedef propagate_const<ExplicitMoveConstructibleFromX> PY;
+
+int main() {
+  static_assert(!std::is_convertible<PY, PX &&>::value, "");
+  static_assert(std::is_constructible<PY, PX &&>::value, "");
+}
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.move_ctor.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.move_ctor.pass.cpp
new file mode 100644
index 000000000000..ee104a5250ea
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.move_ctor.pass.cpp
@@ -0,0 +1,31 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// template <class U> constexpr propagate_const(propagate_const<_Up>&& pu);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+typedef propagate_const<MoveConstructibleFromX> PY;
+typedef propagate_const<X> PX;
+
+int main() {
+  PX px(1);
+  PY py(std::move(px));
+
+  assert(*py==1);
+}
+
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/copy_ctor.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/copy_ctor.pass.cpp
new file mode 100644
index 000000000000..daefdf320e3a
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/copy_ctor.pass.cpp
@@ -0,0 +1,24 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// propagate_const(const propagate_const&)=delete;
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <type_traits>
+
+using std::experimental::propagate_const;
+
+typedef propagate_const<X> P;
+
+int main() { static_assert(!std::is_constructible<P, const P &>::value, ""); }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.explicit.ctor.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.explicit.ctor.pass.cpp
new file mode 100644
index 000000000000..6a7289b2f1a6
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.explicit.ctor.pass.cpp
@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// template <class U> propagate_const(U&&);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <type_traits>
+
+using std::experimental::propagate_const;
+
+typedef propagate_const<ExplicitX> P;
+
+int main() {
+  static_assert(!std::is_convertible<P, int>::value, "");
+  static_assert(std::is_constructible<P, int>::value, "");
+}
+
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type1.fail.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.non-explicit.ctor.pass.cpp
index 85c32ca6d495..9c6ed89f6757 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type1.fail.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.non-explicit.ctor.pass.cpp
@@ -9,19 +9,20 @@
 
 // UNSUPPORTED: c++98, c++03, c++11
 
-#include <tuple>
-#include <string>
-#include <complex>
+// <propagate_const>
 
+// template <class U> propagate_const(U&&);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
 #include <cassert>
 
-int main()
+using std::experimental::propagate_const;
+
+typedef propagate_const<X> P;
+
+void f(const P&)
 {
-#if _LIBCPP_STD_VER > 11
-    typedef std::complex<float> cf;
-    auto t1 = std::make_tuple<int, std::string> ( 42, "Hi" );
-    assert (( std::get<cf>(t1) == cf {1,2} )); // no such type
-#else
-#error
-#endif
 }
+
+int main() { f(2); }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type2.fail.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/move_ctor.pass.cpp
index 0a8d5829d02b..a5adf2d1f7f0 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type2.fail.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/move_ctor.pass.cpp
@@ -9,19 +9,20 @@
 
 // UNSUPPORTED: c++98, c++03, c++11
 
-#include <tuple>
-#include <string>
-#include <complex>
+// <propagate_const>
 
+// propagate_const(propagate_const&&)=default;
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
 #include <cassert>
 
-int main()
-{
-#if _LIBCPP_STD_VER > 11
-    typedef std::complex<float> cf;
-    auto t1 = std::make_tuple<int, int, std::string, cf> ( 42, 21, "Hi", { 1,2 } );
-    assert ( std::get<int>(t1) == 42 ); // two ints here
-#else
-#error
-#endif
+using std::experimental::propagate_const;
+
+int main() {
+
+  typedef propagate_const<X> P;
+
+  P p1(2);
+  P p2(std::move(p1));
 }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/dereference.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/dereference.pass.cpp
new file mode 100644
index 000000000000..5e9e0434fed7
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/dereference.pass.cpp
@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// element_type& propagate_const::operator*();
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+typedef propagate_const<X> P;
+
+constexpr P f()
+{
+  P p(1);
+  *p = 2;
+  return p;
+}
+
+int main() {
+  constexpr P p = f();
+  static_assert(*p==2,"");
+}
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/explicit_operator_element_type_ptr.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/explicit_operator_element_type_ptr.pass.cpp
new file mode 100644
index 000000000000..808eda0e3cc3
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/explicit_operator_element_type_ptr.pass.cpp
@@ -0,0 +1,24 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// propagate_const::operator element_type*();
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <type_traits>
+
+using std::experimental::propagate_const;
+
+typedef propagate_const<X> P;
+
+int main() { static_assert(!std::is_convertible<P, int *>::value, ""); }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/get.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/get.pass.cpp
new file mode 100644
index 000000000000..298389b7b59d
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/get.pass.cpp
@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// element_type* propagate_const::get();
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+typedef propagate_const<X> P;
+
+constexpr P f()
+{
+  P p(1);
+  *p.get() = 2;
+  return p;
+}
+
+int main() {
+  constexpr P p = f();
+  static_assert(*(p.get())==2,"");
+}
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/op_arrow.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/op_arrow.pass.cpp
new file mode 100644
index 000000000000..810e86eea172
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/op_arrow.pass.cpp
@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// element_type* propagate_const::operator->();
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+typedef propagate_const<X> P;
+
+constexpr P f()
+{
+  P p(1);
+  *(p.operator->()) = 2;
+  return p;
+}
+
+int main() {
+  constexpr P p = f();
+  static_assert(*(p.operator->())==2,"");
+}
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/operator_element_type_ptr.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/operator_element_type_ptr.pass.cpp
new file mode 100644
index 000000000000..6bdf76c92e99
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/operator_element_type_ptr.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, c++11
+
+// <propagate_const>
+
+// propagate_const::operator element_type*();
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+int main() {
+
+  typedef propagate_const<XWithImplicitIntStarConversion> P;
+
+  P p(1);
+
+  int* ptr_1 = p;
+
+  assert(*ptr_1==1);
+
+  *ptr_1 = 2;
+
+  assert(*ptr_1==2);
+}
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/dereference.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/dereference.pass.cpp
new file mode 100644
index 000000000000..292335449649
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/dereference.pass.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// const element_type& propagate_const::operator*() const;
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+int main() {
+
+  typedef propagate_const<X> P;
+
+  constexpr P p(1);
+
+  static_assert(*p==1,"");
+}
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/explicit_operator_element_type_ptr.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/explicit_operator_element_type_ptr.pass.cpp
new file mode 100644
index 000000000000..b9b6b3f90f23
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/explicit_operator_element_type_ptr.pass.cpp
@@ -0,0 +1,26 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// propagate_const::operator const element_type*() const;
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <type_traits>
+
+using std::experimental::propagate_const;
+
+typedef propagate_const<X> P;
+
+int main() {
+  static_assert(!std::is_convertible<const P, const int *>::value, "");
+}
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/get.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/get.pass.cpp
new file mode 100644
index 000000000000..8029ff47475e
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/get.pass.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// const element_type* propagate_const::get() const;
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+int main() {
+
+  typedef propagate_const<X> P;
+
+  constexpr P p(1);
+
+  static_assert(*(p.get())==1, "");
+}
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/op_arrow.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/op_arrow.pass.cpp
new file mode 100644
index 000000000000..4ceea8a1d781
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/op_arrow.pass.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// const element_type* propagate_const::operator->() const;
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+int main() {
+
+  typedef propagate_const<X> P;
+
+  constexpr P p(1);
+
+  static_assert(*(p.operator->())==1,"");
+}
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/operator_element_type_ptr.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/operator_element_type_ptr.pass.cpp
new file mode 100644
index 000000000000..1ac6d254a342
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/operator_element_type_ptr.pass.cpp
@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// propagate_const::operator const element_type*() const;
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+typedef propagate_const<XWithImplicitConstIntStarConversion> P;
+
+constexpr P p(1);
+
+constexpr const int *ptr_1 = p;
+
+int main() { assert(*ptr_1 == 1); }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/swap.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/swap.pass.cpp
new file mode 100644
index 000000000000..c5c832bbe0c2
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/swap.pass.cpp
@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// template <class T> constexpr void propagate_const::swap(propagate_const<T>& x);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+bool swap_called = false;
+void swap(X &, X &) { swap_called = true; }
+
+int main() {
+  typedef propagate_const<X> P;
+  P p1(1);
+  P p2(2);
+  p1.swap(p2);
+  assert(swap_called);
+}
+
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/hash.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/hash.pass.cpp
new file mode 100644
index 000000000000..8cf670a25402
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/hash.pass.cpp
@@ -0,0 +1,44 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// template <class T> struct hash<experimental::fundamentals_v2::propagate_const<T>>;
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+namespace std {
+template <> struct hash<X>
+{
+  typedef X first_argument_type;
+
+  size_t operator()(const first_argument_type& x1) const
+  {
+    return 99;
+  }
+
+};
+} // namespace std
+
+int main() {
+
+  typedef propagate_const<X> P;
+
+  P p(1);
+
+  auto h = std::hash<P>();
+
+  assert(h(p)==99);
+}
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/equal_to.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/equal_to.pass.cpp
new file mode 100644
index 000000000000..d54222a97a1c
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/equal_to.pass.cpp
@@ -0,0 +1,36 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// template <class T> struct equal_to<experimental::fundamentals_v2::propagate_const<T>>;
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+constexpr bool operator==(const X &x1, const X &x2) { return x1.i_ == x2.i_; }
+
+int main() {
+
+  typedef propagate_const<X> P;
+
+  P p1_1(1);
+  P p2_1(1);
+  P p3_2(2);
+
+  auto c = std::equal_to<P>();
+
+  assert(c(p1_1,p2_1));
+  assert(!c(p1_1,p3_2));
+}
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater.pass.cpp
new file mode 100644
index 000000000000..fb8e1282f214
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater.pass.cpp
@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// template <class T> struct greater<experimental::fundamentals_v2::propagate_const<T>>;
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+constexpr bool operator>(const X &x1, const X &x2) { return x1.i_ > x2.i_; }
+
+int main() {
+
+  typedef propagate_const<X> P;
+
+  P p1_1(1);
+  P p2_1(1);
+  P p3_2(2);
+
+  auto c = std::greater<P>();
+
+  assert(!c(p1_1,p2_1));
+  assert(!c(p2_1,p1_1));
+  assert(!c(p1_1,p3_2));
+  assert(c(p3_2,p1_1));
+}
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater_equal.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater_equal.pass.cpp
new file mode 100644
index 000000000000..29a1868d6471
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater_equal.pass.cpp
@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// template <class T> struct greater_equal<experimental::fundamentals_v2::propagate_const<T>>;
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+constexpr bool operator>=(const X &x1, const X &x2) { return x1.i_ >= x2.i_; }
+
+int main() {
+
+  typedef propagate_const<X> P;
+
+  P p1_1(1);
+  P p2_1(1);
+  P p3_2(2);
+
+  auto c = std::greater_equal<P>();
+
+  assert(c(p1_1,p2_1));
+  assert(c(p2_1,p1_1));
+  assert(!c(p1_1,p3_2));
+  assert(c(p3_2,p1_1));
+}
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less.pass.cpp
new file mode 100644
index 000000000000..074a3914a51c
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less.pass.cpp
@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// template <class T> struct less<experimental::fundamentals_v2::propagate_const<T>>;
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+constexpr bool operator<(const X &x1, const X &x2) { return x1.i_ < x2.i_; }
+
+int main() {
+
+  typedef propagate_const<X> P;
+
+  P p1_1(1);
+  P p2_1(1);
+  P p3_2(2);
+
+  auto c = std::less<P>();
+
+  assert(!c(p1_1,p2_1));
+  assert(!c(p2_1,p1_1));
+  assert(c(p1_1,p3_2));
+  assert(!c(p3_2,p1_1));
+}
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less_equal.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less_equal.pass.cpp
new file mode 100644
index 000000000000..a2082ec5cb31
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less_equal.pass.cpp
@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// template <class T> struct less_equal<experimental::fundamentals_v2::propagate_const<T>>;
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+constexpr bool operator<=(const X &x1, const X &x2) { return x1.i_ <= x2.i_; }
+
+int main() {
+
+  typedef propagate_const<X> P;
+
+  P p1_1(1);
+  P p2_1(1);
+  P p3_2(2);
+
+  auto c = std::less_equal<P>();
+
+  assert(c(p1_1,p2_1));
+  assert(c(p2_1,p1_1));
+  assert(c(p1_1,p3_2));
+  assert(!c(p3_2,p1_1));
+}
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/not_equal_to.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/not_equal_to.pass.cpp
new file mode 100644
index 000000000000..20756d984e94
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/not_equal_to.pass.cpp
@@ -0,0 +1,36 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// template <class T> struct not_equal_to<experimental::fundamentals_v2::propagate_const<T>>;
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+constexpr bool operator!=(const X &x1, const X &x2) { return x1.i_ != x2.i_; }
+
+int main() {
+
+  typedef propagate_const<X> P;
+
+  P p1_1(1);
+  P p2_1(1);
+  P p3_2(2);
+
+  auto c = std::not_equal_to<P>();
+
+  assert(!c(p1_1,p2_1));
+  assert(c(p1_1,p3_2));
+}
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/equal.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/equal.pass.cpp
new file mode 100644
index 000000000000..a4a28b48a545
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/equal.pass.cpp
@@ -0,0 +1,64 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// template <class T> constexpr bool operator==(const propagate_const<T>& x, const propagate_const<T>& y);
+// template <class T> constexpr bool operator==(const T& x, const propagate_const<T>& y);
+// template <class T> constexpr bool operator==(const propagate_const<T>& x, const T& y);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+using std::nullptr_t;
+
+constexpr bool operator==(const X &lhs, const X &rhs) {
+  return lhs.i_ == rhs.i_;
+}
+
+constexpr bool operator==(const X &, const nullptr_t &) {
+  return false;
+}
+
+constexpr bool operator==(const nullptr_t &, const X &) {
+  return false;
+}
+
+int main() {
+  constexpr X x1_1(1);
+  constexpr X x2_1(1);
+  constexpr X x3_2(2);
+
+  static_assert(x1_1 == x1_1, "");
+  static_assert(x1_1 == x2_1, "");
+  static_assert(!(x1_1 == x3_2), "");
+
+  typedef propagate_const<X> P;
+
+  constexpr P p1_1(1);
+  constexpr P p2_1(1);
+  constexpr P p3_2(2);
+
+  static_assert(p1_1 == p1_1, "");
+  static_assert(p1_1 == p2_1, "");
+  static_assert(!(p1_1 == p3_2), "");
+
+  static_assert(x1_1 == p1_1, "");
+  static_assert(!(x1_1 == p3_2), "");
+
+  static_assert(p1_1 == x1_1, "");
+  static_assert(!(p1_1 == x3_2), "");
+
+  static_assert(!(p1_1==nullptr),"");
+  static_assert(!(nullptr==p1_1),"");
+}
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_equal.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_equal.pass.cpp
new file mode 100644
index 000000000000..4b5b42467c09
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_equal.pass.cpp
@@ -0,0 +1,54 @@
+//>==---------------------------------------------------------------------->==//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// template <class T> constexpr bool operator>=(const propagate_const<T>& x, const propagate_const<T>& y);
+// template <class T> constexpr bool operator>=(const T& x, const propagate_const<T>& y);
+// template <class T> constexpr bool operator>=(const propagate_const<T>& x, const T& y);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+constexpr bool operator>=(const X &lhs, const X &rhs) {
+  return lhs.i_ >= rhs.i_;
+}
+
+int main() {
+  constexpr X x1_1(1);
+  constexpr X x2_1(1);
+  constexpr X x3_2(2);
+
+  static_assert(x1_1 >= x2_1, "");
+  static_assert(!(x1_1 >= x3_2), "");
+  static_assert(x3_2 >= x1_1, "");
+
+  typedef propagate_const<X> P;
+
+  constexpr P p1_1(1);
+  constexpr P p2_1(1);
+  constexpr P p3_2(2);
+
+  static_assert(p1_1 >= p2_1, "");
+  static_assert(!(p1_1 >= p3_2), "");
+  static_assert(p3_2 >= p1_1, "");
+
+  static_assert(p1_1 >= x2_1, "");
+  static_assert(!(p1_1 >= x3_2), "");
+  static_assert(p3_2 >= x1_1, "");
+
+  static_assert(x1_1 >= p2_1, "");
+  static_assert(!(x1_1 >= p3_2), "");
+  static_assert(x3_2 >= p1_1, "");
+}
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_than.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_than.pass.cpp
new file mode 100644
index 000000000000..3865b9370727
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_than.pass.cpp
@@ -0,0 +1,50 @@
+//>=---------------------------------------------------------------------->=//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// template <class T> constexpr bool operator>(const propagate_const<T>& x, const propagate_const<T>& y);
+// template <class T> constexpr bool operator>(const T& x, const propagate_const<T>& y);
+// template <class T> constexpr bool operator>(const propagate_const<T>& x, const T& y);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+constexpr bool operator>(const X &lhs, const X &rhs) {
+  return lhs.i_ > rhs.i_;
+}
+
+int main() {
+  constexpr X x1_1(1);
+  constexpr X x2_1(1);
+  constexpr X x3_2(2);
+
+  static_assert(!(x1_1 > x2_1), "");
+  static_assert(x3_2 > x1_1, "");
+
+  typedef propagate_const<X> P;
+
+  constexpr P p1_1(1);
+  constexpr P p2_1(1);
+  constexpr P p3_2(2);
+
+  static_assert(!(p1_1 > p2_1), "");
+  static_assert(p3_2 > p1_1, "");
+
+  static_assert(!(p1_1 > x2_1), "");
+  static_assert(p3_2 > x1_1, "");
+
+  static_assert(!(x1_1 > p2_1), "");
+  static_assert(x3_2 > p1_1, "");
+}
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_equal.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_equal.pass.cpp
new file mode 100644
index 000000000000..3ac12c27f8bb
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_equal.pass.cpp
@@ -0,0 +1,55 @@
+//<==----------------------------------------------------------------------<==//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// template <class T> constexpr bool operator<=(const propagate_const<T>& x, const propagate_const<T>& y);
+// template <class T> constexpr bool operator<=(const T& x, const propagate_const<T>& y);
+// template <class T> constexpr bool operator<=(const propagate_const<T>& x, const T& y);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+constexpr bool operator<=(const X &lhs, const X &rhs) {
+  return lhs.i_ <= rhs.i_;
+}
+
+int main() {
+  constexpr X x1_1(1);
+  constexpr X x2_1(1);
+  constexpr X x3_2(2);
+
+  static_assert(x1_1 <= x2_1, "");
+  static_assert(x1_1 <= x3_2, "");
+  static_assert(!(x3_2 <= x1_1), "");
+
+  typedef propagate_const<X> P;
+
+  constexpr P p1_1(1);
+  constexpr P p2_1(1);
+  constexpr P p3_2(2);
+
+  static_assert(p1_1 <= p2_1, "");
+  static_assert(p1_1 <= p3_2, "");
+  static_assert(!(p3_2 <= p1_1), "");
+
+  static_assert(p1_1 <= x2_1, "");
+  static_assert(p1_1 <= x3_2, "");
+  static_assert(!(p3_2 <= x1_1), "");
+
+  static_assert(x1_1 <= p2_1, "");
+  static_assert(x1_1 <= p3_2, "");
+  static_assert(!(x3_2 <= p1_1), "");
+
+}
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_than.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_than.pass.cpp
new file mode 100644
index 000000000000..42b2730c58cc
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_than.pass.cpp
@@ -0,0 +1,50 @@
+//<=----------------------------------------------------------------------<=//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// template <class T> constexpr bool operator<(const propagate_const<T>& x, const propagate_const<T>& y);
+// template <class T> constexpr bool operator<(const T& x, const propagate_const<T>& y);
+// template <class T> constexpr bool operator<(const propagate_const<T>& x, const T& y);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+constexpr bool operator<(const X &lhs, const X &rhs) {
+  return lhs.i_ < rhs.i_;
+}
+
+int main() {
+  constexpr X x1_1(1);
+  constexpr X x2_1(1);
+  constexpr X x3_2(2);
+
+  static_assert(!(x1_1 < x2_1), "");
+  static_assert(x1_1 < x3_2, "");
+
+  typedef propagate_const<X> P;
+
+  constexpr P p1_1(1);
+  constexpr P p2_1(1);
+  constexpr P p3_2(2);
+
+  static_assert(!(p1_1 < p2_1), "");
+  static_assert(p1_1 < p3_2, "");
+
+  static_assert(!(x1_1 < p1_1), "");
+  static_assert(x1_1 < p3_2, "");
+
+  static_assert(!(p1_1 < x1_1), "");
+  static_assert(p1_1 < x3_2, "");
+}
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/not_equal.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/not_equal.pass.cpp
new file mode 100644
index 000000000000..1104abdecb6d
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/not_equal.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, c++11
+
+// <propagate_const>
+
+// template <class T> constexpr bool operator!=(const propagate_const<T>& x, const propagate_const<T>& y);
+// template <class T> constexpr bool operator!=(const T& x, const propagate_const<T>& y);
+// template <class T> constexpr bool operator!=(const propagate_const<T>& x, const T& y);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+using std::nullptr_t;
+
+constexpr bool operator!=(const X &lhs, const X &rhs) {
+  return lhs.i_ != rhs.i_;
+}
+
+constexpr bool operator!=(const X &, const nullptr_t &) {
+  return true;
+}
+
+constexpr bool operator!=(const nullptr_t &, const X &) {
+  return true;
+}
+
+int main() {
+  constexpr X x1_1(1);
+  constexpr X x2_1(1);
+  constexpr X x3_2(2);
+
+  static_assert(!(x1_1 != x2_1), "");
+  static_assert(x1_1 != x3_2, "");
+
+  typedef propagate_const<X> P;
+
+  constexpr P p1_1(1);
+  constexpr P p2_1(1);
+  constexpr P p3_2(2);
+
+  static_assert(!(p1_1 != p2_1), "");
+  static_assert(p1_1 != p3_2, "");
+
+  static_assert(!(x1_1 != p1_1), "");
+  static_assert(x1_1 != p3_2, "");
+
+  static_assert(!(p1_1 != x1_1), "");
+  static_assert(p1_1 != x3_2, "");
+
+  static_assert(p1_1!=nullptr,"");
+  static_assert(nullptr!=p1_1,"");
+}
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/swap.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/swap.pass.cpp
new file mode 100644
index 000000000000..6c3b60948965
--- /dev/null
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/swap.pass.cpp
@@ -0,0 +1,31 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+// <propagate_const>
+
+// template <class T> constexpr void swap(propagate_const<T>& x, propagate_const<T>& y);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+bool swap_called = false;
+void swap(X &, X &) { swap_called = true; }
+
+int main() {
+  typedef propagate_const<X> P;
+  P p1(1);
+  P p2(2);
+  swap(p1, p2);
+  assert(swap_called);
+}
diff --git a/test/std/experimental/utilities/tuple/tuple.apply/constexpr_types.pass.cpp b/test/std/experimental/utilities/tuple/tuple.apply/constexpr_types.pass.cpp
index 2d700486f26b..5b8a8f09d1ee 100644
--- a/test/std/experimental/utilities/tuple/tuple.apply/constexpr_types.pass.cpp
+++ b/test/std/experimental/utilities/tuple/tuple.apply/constexpr_types.pass.cpp
@@ -9,11 +9,6 @@
 
 // UNSUPPORTED: c++98, c++03, c++11
 
-// TODO(ericwf)
-// constexpr support temporarily reverted due to bug:
-// https://llvm.org/bugs/show_bug.cgi?id=23141
-// XFAIL: *
-
 // <experimental/tuple>
 
 // template <class F, class T> constexpr decltype(auto) apply(F &&, T &&)
diff --git a/test/std/experimental/utilities/tuple/tuple.apply/return_type.pass.cpp b/test/std/experimental/utilities/tuple/tuple.apply/return_type.pass.cpp
index 1ec38da5c043..314d2783f7ec 100644
--- a/test/std/experimental/utilities/tuple/tuple.apply/return_type.pass.cpp
+++ b/test/std/experimental/utilities/tuple/tuple.apply/return_type.pass.cpp
@@ -25,30 +25,27 @@ template <int N> struct index {};
 void f(index<0>) {}
 
 int f(index<1>) { return 0; }
-int const f(index<2>) { return 0; }
-int volatile f(index<3>) { return 0; }
-int const volatile f(index<4>) { return 0; }
 
-int & f(index<5>) { return static_cast<int &>(my_int); }
-int const & f(index<6>) { return static_cast<int const &>(my_int); }
-int volatile & f(index<7>) { return static_cast<int volatile &>(my_int); }
-int const volatile & f(index<8>) { return static_cast<int const volatile &>(my_int); }
+int & f(index<2>) { return static_cast<int &>(my_int); }
+int const & f(index<3>) { return static_cast<int const &>(my_int); }
+int volatile & f(index<4>) { return static_cast<int volatile &>(my_int); }
+int const volatile & f(index<5>) { return static_cast<int const volatile &>(my_int); }
 
-int && f(index<9>) { return static_cast<int &&>(my_int); }
-int const && f(index<10>) { return static_cast<int const &&>(my_int); }
-int volatile && f(index<11>) { return static_cast<int volatile &&>(my_int); }
-int const volatile && f(index<12>) { return static_cast<int const volatile &&>(my_int); }
+int && f(index<6>) { return static_cast<int &&>(my_int); }
+int const && f(index<7>) { return static_cast<int const &&>(my_int); }
+int volatile && f(index<8>) { return static_cast<int volatile &&>(my_int); }
+int const volatile && f(index<9>) { return static_cast<int const volatile &&>(my_int); }
 
-int * f(index<13>) { return static_cast<int *>(&my_int); }
-int const * f(index<14>) { return static_cast<int const *>(&my_int); }
-int volatile * f(index<15>) { return static_cast<int volatile *>(&my_int); }
-int const volatile * f(index<16>) { return static_cast<int const volatile *>(&my_int); }
+int * f(index<10>) { return static_cast<int *>(&my_int); }
+int const * f(index<11>) { return static_cast<int const *>(&my_int); }
+int volatile * f(index<12>) { return static_cast<int volatile *>(&my_int); }
+int const volatile * f(index<13>) { return static_cast<int const volatile *>(&my_int); }
 
 
 template <int Func, class Expect>
 void test()
 {
-    using F = decltype((f(index<Func>{})));
+    using F = decltype(f(index<Func>{}));
     static_assert(std::is_same<F, Expect>::value, "");
 }
 
@@ -58,19 +55,16 @@ int main()
 {
     test<0, void>();
     test<1, int>();
-    //test<2, int const>();
-    //test<3, int volatile>();
-    //test<4, int const volatile>();
-    test<5, int &>();
-    test<6, int const &>();
-    test<7, int volatile &>();
-    test<8, int const volatile &>();
-    test<9, int &&>();
-    test<10, int const &&>();
-    test<11, int volatile &&>();
-    test<12, int const volatile &&>();
-    test<13, int *>();
-    test<14, int const *>();
-    test<15, int volatile *>();
-    test<16, int const volatile *>();
+    test<2, int &>();
+    test<3, int const &>();
+    test<4, int volatile &>();
+    test<5, int const volatile &>();
+    test<6, int &&>();
+    test<7, int const &&>();
+    test<8, int volatile &&>();
+    test<9, int const volatile &&>();
+    test<10, int *>();
+    test<11, int const *>();
+    test<12, int volatile *>();
+    test<13, int const volatile *>();
 }
diff --git a/test/std/input.output/file.streams/c.files/cinttypes.pass.cpp b/test/std/input.output/file.streams/c.files/cinttypes.pass.cpp
index 4cb2c4c2f448..8937950522c8 100644
--- a/test/std/input.output/file.streams/c.files/cinttypes.pass.cpp
+++ b/test/std/input.output/file.streams/c.files/cinttypes.pass.cpp
@@ -917,7 +917,7 @@ int main()
     std::uintmax_t i4 = 0;
     }
     {
-    std::imaxdiv_t  i1 = {0};
+    std::imaxdiv_t  i1 = {};
     }
     std::intmax_t i = 0;
     static_assert((std::is_same<decltype(std::imaxabs(i)), std::intmax_t>::value), "");
diff --git a/test/std/input.output/file.streams/c.files/cstdio.pass.cpp b/test/std/input.output/file.streams/c.files/cstdio.pass.cpp
index a06f0443d701..4c2be7d4aa9e 100644
--- a/test/std/input.output/file.streams/c.files/cstdio.pass.cpp
+++ b/test/std/input.output/file.streams/c.files/cstdio.pass.cpp
@@ -78,17 +78,24 @@
 
 #include <cstdarg>
 
+#if defined(__clang__)
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wformat-zero-length"
 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#endif
 
 int main()
 {
     std::FILE* fp = 0;
-    std::fpos_t fpos = {0};
+    std::fpos_t fpos = {};
     std::size_t s = 0;
     char* cp = 0;
     std::va_list va;
+    ((void)fp); // Prevent unused warning
+    ((void)fpos); // Prevent unused warning
+    ((void)s); // Prevent unused warning
+    ((void)cp); // Prevent unused warning
+    ((void)va); // Prevent unused warning
     static_assert((std::is_same<decltype(std::fclose(fp)), int>::value), "");
     static_assert((std::is_same<decltype(std::fflush(fp)), int>::value), "");
     static_assert((std::is_same<decltype(std::setbuf(fp,cp)), void>::value), "");
diff --git a/test/std/input.output/file.streams/c.files/gets.fail.cpp b/test/std/input.output/file.streams/c.files/gets.fail.cpp
index 4250e23c11c2..064d72cd9e4a 100644
--- a/test/std/input.output/file.streams/c.files/gets.fail.cpp
+++ b/test/std/input.output/file.streams/c.files/gets.fail.cpp
@@ -7,17 +7,14 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // test <cstdio>
 
-// gets 
+// gets
 
 #include <cstdio>
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     (void) std::gets((char *) NULL);
-#else
-#error
-#endif
 }
diff --git a/test/std/input.output/iostream.format/ext.manip/get_time.pass.cpp b/test/std/input.output/iostream.format/ext.manip/get_time.pass.cpp
index a8b82a62bb6b..553c2b2eb3a0 100644
--- a/test/std/input.output/iostream.format/ext.manip/get_time.pass.cpp
+++ b/test/std/input.output/iostream.format/ext.manip/get_time.pass.cpp
@@ -44,7 +44,7 @@ int main()
         testbuf<char> sb("  Sat Dec 31 23:55:59 2061");
         std::istream is(&sb);
         is.imbue(std::locale(LOCALE_en_US_UTF_8));
-        std::tm t = {0};
+        std::tm t = {};
         is >> std::get_time(&t, "%a %b %d %H:%M:%S %Y");
         assert(t.tm_sec == 59);
         assert(t.tm_min == 55);
@@ -60,7 +60,7 @@ int main()
         testbuf<wchar_t> sb(L"  Sat Dec 31 23:55:59 2061");
         std::wistream is(&sb);
         is.imbue(std::locale(LOCALE_en_US_UTF_8));
-        std::tm t = {0};
+        std::tm t = {};
         is >> std::get_time(&t, L"%a %b %d %H:%M:%S %Y");
         assert(t.tm_sec == 59);
         assert(t.tm_min == 55);
diff --git a/test/std/input.output/iostream.format/ext.manip/put_time.pass.cpp b/test/std/input.output/iostream.format/ext.manip/put_time.pass.cpp
index f4e3ded1745c..e907708d0f22 100644
--- a/test/std/input.output/iostream.format/ext.manip/put_time.pass.cpp
+++ b/test/std/input.output/iostream.format/ext.manip/put_time.pass.cpp
@@ -56,7 +56,7 @@ int main()
         testbuf<char> sb;
         std::ostream os(&sb);
         os.imbue(std::locale(LOCALE_en_US_UTF_8));
-        std::tm t = {0};
+        std::tm t = {};
         t.tm_sec = 59;
         t.tm_min = 55;
         t.tm_hour = 23;
@@ -72,7 +72,7 @@ int main()
         testbuf<wchar_t> sb;
         std::wostream os(&sb);
         os.imbue(std::locale(LOCALE_en_US_UTF_8));
-        std::tm t = {0};
+        std::tm t = {};
         t.tm_sec = 59;
         t.tm_min = 55;
         t.tm_hour = 23;
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/ignore_0xff.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/ignore_0xff.pass.cpp
index ccc3545483e7..e498172aa8b1 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/ignore_0xff.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/ignore_0xff.pass.cpp
@@ -21,10 +21,10 @@ int main()
 {
     int bad=-1;
     std::ostringstream os;
-    os << "aaaabbbb" << static_cast<char>(bad) 
+    os << "aaaabbbb" << static_cast<char>(bad)
        << "ccccdddd" << std::endl;
     std::string s=os.str();
-    
+
     std::istringstream is(s);
     const unsigned int ignoreLen=10;
     size_t a=is.tellg();
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/seekg_off.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/seekg_off.pass.cpp
index 3cedf9192808..818d42c26212 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/seekg_off.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/seekg_off.pass.cpp
@@ -40,7 +40,7 @@ public:
     CharT* egptr() const {return base::egptr();}
 protected:
     typename base::pos_type seekoff(typename base::off_type off,
-                                    std::ios_base::seekdir way,
+                                    std::ios_base::seekdir,
                                     std::ios_base::openmode which)
     {
         assert(which == std::ios_base::in);
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minus1.pass b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minus1.pass.cpp
index 27b8cfd85c96..47e257a18684 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minus1.pass
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minus1.pass.cpp
@@ -21,8 +21,10 @@
 
 //  Testing to make sure that the max length values are correctly inserted
 
-#include <iostream>
 #include <sstream>
+#include <ios>
+#include <cctype>
+#include <cstdint>
 #include <cassert>
 
 template <typename T>
@@ -30,7 +32,6 @@ void test_octal(const char *expected)
 {
     std::stringstream ss;
     ss << std::oct << static_cast<T>(-1);
-    
     assert(ss.str() == expected);
 }
 
@@ -39,8 +40,6 @@ void test_dec(const char *expected)
 {
     std::stringstream ss;
     ss << std::dec << static_cast<T>(-1);
-    
-//  std::cout << ss.str() << " " << expected << std::endl;
     assert(ss.str() == expected);
 }
 
@@ -49,22 +48,32 @@ void test_hex(const char *expected)
 {
     std::stringstream ss;
     ss << std::hex << static_cast<T>(-1);
-    
+
     std::string str = ss.str();
     for (size_t i = 0; i < str.size(); ++i )
         str[i] = std::toupper(str[i]);
-    
+
     assert(str == expected);
 }
 
-int main(int argc, char* argv[])
+int main()
 {
+
     test_octal<uint16_t>(                "177777");
     test_octal< int16_t>(                "177777");
     test_octal<uint32_t>(           "37777777777");
     test_octal< int32_t>(           "37777777777");
     test_octal<uint64_t>("1777777777777777777777");
     test_octal< int64_t>("1777777777777777777777");
+    test_octal<uint64_t>("1777777777777777777777");
+    if (sizeof(long) == sizeof(int64_t)) {
+        test_octal< unsigned long>("1777777777777777777777");
+        test_octal<          long>("1777777777777777777777");
+    }
+    if (sizeof(long long) == sizeof(int64_t)) {
+        test_octal< unsigned long long>("1777777777777777777777");
+        test_octal<          long long>("1777777777777777777777");
+    }
 
     test_dec<uint16_t>(               "65535");
     test_dec< int16_t>(                  "-1");
@@ -72,6 +81,14 @@ int main(int argc, char* argv[])
     test_dec< int32_t>(                  "-1");
     test_dec<uint64_t>("18446744073709551615");
     test_dec< int64_t>(                  "-1");
+    if (sizeof(long) == sizeof(int64_t)) {
+        test_dec<unsigned long>("18446744073709551615");
+        test_dec<         long>(                  "-1");
+    }
+    if (sizeof(long long) == sizeof(int64_t)) {
+        test_dec<unsigned long long>("18446744073709551615");
+        test_dec<         long long>(                  "-1");
+    }
 
     test_hex<uint16_t>(            "FFFF");
     test_hex< int16_t>(            "FFFF");
@@ -79,6 +96,12 @@ int main(int argc, char* argv[])
     test_hex< int32_t>(        "FFFFFFFF");
     test_hex<uint64_t>("FFFFFFFFFFFFFFFF");
     test_hex< int64_t>("FFFFFFFFFFFFFFFF");
-
-    return 0;
+    if (sizeof(long) == sizeof(int64_t)) {
+        test_hex<unsigned long>("FFFFFFFFFFFFFFFF");
+        test_hex<         long>("FFFFFFFFFFFFFFFF");
+    }
+    if (sizeof(long long) == sizeof(int64_t)) {
+        test_hex<unsigned long long>("FFFFFFFFFFFFFFFF");
+        test_hex<         long long>("FFFFFFFFFFFFFFFF");
+    }
 }
diff --git a/test/std/input.output/iostream.format/quoted.manip/quoted.pass.cpp b/test/std/input.output/iostream.format/quoted.manip/quoted.pass.cpp
index d09b3cae4f66..ee9aabcb6ac8 100644
--- a/test/std/input.output/iostream.format/quoted.manip/quoted.pass.cpp
+++ b/test/std/input.output/iostream.format/quoted.manip/quoted.pass.cpp
@@ -16,79 +16,95 @@
 #include <string>
 #include <cassert>
 
-#if _LIBCPP_STD_VER > 11
-
-bool is_skipws ( const std::istream *is ) {
-    return ( is->flags() & std::ios_base::skipws ) != 0;
-    }
+#include "test_macros.h"
 
+#if TEST_STD_VER > 11
 
-bool is_skipws ( const std::wistream *is ) {
-    return ( is->flags() & std::ios_base::skipws ) != 0;
+template <class CharT, class Traits>
+bool is_skipws ( const std::basic_istream<CharT, Traits>& is ) {
+    return ( is.flags() & std::ios_base::skipws ) != 0;
     }
 
-void both_ways ( const char *p ) {
-    std::string str(p);
+template <class CharT, class Traits = std::char_traits<CharT>>
+void both_ways ( const CharT *p ) {
+    std::basic_string<CharT, Traits> str(p);
     auto q = std::quoted(str);
 
-    std::stringstream ss;
-    bool skippingws = is_skipws ( &ss );
+    std::basic_stringstream<CharT, Traits> ss;
+    bool skippingws = is_skipws ( ss );
     ss << q;
     ss >> q;
     }
 
-void round_trip ( const char *p ) {
-    std::stringstream ss;
-    bool skippingws = is_skipws ( &ss );
+template <class CharT, class Traits = std::char_traits<CharT>>
+void round_trip ( const CharT *p ) {
+    std::basic_stringstream<CharT, Traits> ss;
+    bool skippingws = is_skipws ( ss );
+
     ss << std::quoted(p);
-    std::string s;
+    std::basic_string<CharT, Traits> s;
     ss >> std::quoted(s);
     assert ( s == p );
-    assert ( skippingws == is_skipws ( &ss ));
+    assert ( skippingws == is_skipws ( ss ));
     }
 
-void round_trip_ws ( const char *p ) {
-    std::stringstream ss;
+
+template <class CharT, class Traits = std::char_traits<CharT>>
+void round_trip_ws ( const CharT *p ) {
+    std::basic_stringstream<CharT, Traits> ss;
     std::noskipws ( ss );
-    bool skippingws = is_skipws ( &ss );
+    bool skippingws = is_skipws ( ss );
+
     ss << std::quoted(p);
-    std::string s;
+    std::basic_string<CharT, Traits> s;
     ss >> std::quoted(s);
     assert ( s == p );
-    assert ( skippingws == is_skipws ( &ss ));
+    assert ( skippingws == is_skipws ( ss ));
     }
 
-void round_trip_d ( const char *p, char delim ) {
-    std::stringstream ss;
-    ss << std::quoted(p, delim);
-    std::string s;
-    ss >> std::quoted(s, delim);
+template <class CharT, class Traits = std::char_traits<CharT>>
+void round_trip_d ( const CharT *p, char delim ) {
+    std::basic_stringstream<CharT, Traits> ss;
+    CharT d(delim);
+
+    ss << std::quoted(p, d);
+    std::basic_string<CharT, Traits> s;
+    ss >> std::quoted(s, d);
     assert ( s == p );
     }
 
-void round_trip_e ( const char *p, char escape ) {
-    std::stringstream ss;
-    ss << std::quoted(p, '"', escape );
-    std::string s;
-    ss >> std::quoted(s, '"', escape );
+template <class CharT, class Traits = std::char_traits<CharT>>
+void round_trip_e ( const CharT *p, char escape ) {
+    std::basic_stringstream<CharT, Traits> ss;
+    CharT e(escape);
+
+    ss << std::quoted(p, CharT('"'), e );
+    std::basic_string<CharT, Traits> s;
+    ss >> std::quoted(s, CharT('"'), e );
     assert ( s == p );
     }
 
 
-
-std::string quote ( const char *p, char delim='"', char escape='\\' ) {
-    std::stringstream ss;
-    ss << std::quoted(p, delim, escape);
-    std::string s;
+template <class CharT, class Traits = std::char_traits<CharT>>
+std::basic_string<CharT, Traits> quote ( const CharT *p, char delim='"', char escape='\\' ) {
+    std::basic_stringstream<CharT, Traits> ss;
+    CharT d(delim);
+    CharT e(escape);
+    ss << std::quoted(p, d, e);
+    std::basic_string<CharT, Traits> s;
     ss >> s;    // no quote
     return s;
 }
 
-std::string unquote ( const char *p, char delim='"', char escape='\\' ) {
-    std::stringstream ss;
+template <class CharT, class Traits = std::char_traits<CharT>>
+std::basic_string<CharT, Traits> unquote ( const CharT *p, char delim='"', char escape='\\' ) {
+    std::basic_stringstream<CharT, Traits> ss;
     ss << p;
-    std::string s;
-    ss >> std::quoted(s, delim, escape);
+
+    CharT d(delim);
+    CharT e(escape);
+    std::basic_string<CharT, Traits> s;
+    ss >> std::quoted(s, d, e);
     return s;
 }
 
@@ -98,7 +114,7 @@ void test_padding () {
     ss << std::left << std::setw(10) << std::setfill('!') << std::quoted("abc", '`');
     assert ( ss.str() == "`abc`!!!!!" );
     }
-    
+
     {
     std::stringstream ss;
     ss << std::right << std::setw(10) << std::setfill('!') << std::quoted("abc", '`');
@@ -107,61 +123,6 @@ void test_padding () {
 }
 
 
-void round_trip ( const wchar_t *p ) {
-    std::wstringstream ss;
-    bool skippingws = is_skipws ( &ss );
-    ss << std::quoted(p);
-    std::wstring s;
-    ss >> std::quoted(s);
-    assert ( s == p );
-    assert ( skippingws == is_skipws ( &ss ));
-    }
-    
-
-void round_trip_ws ( const wchar_t *p ) {
-    std::wstringstream ss;
-    std::noskipws ( ss );
-    bool skippingws = is_skipws ( &ss );
-    ss << std::quoted(p);
-    std::wstring s;
-    ss >> std::quoted(s);
-    assert ( s == p );
-    assert ( skippingws == is_skipws ( &ss ));
-    }
-
-void round_trip_d ( const wchar_t *p, wchar_t delim ) {
-    std::wstringstream ss;
-    ss << std::quoted(p, delim);
-    std::wstring s;
-    ss >> std::quoted(s, delim);
-    assert ( s == p );
-    }
-
-void round_trip_e ( const wchar_t *p, wchar_t escape ) {
-    std::wstringstream ss;
-    ss << std::quoted(p, wchar_t('"'), escape );
-    std::wstring s;
-    ss >> std::quoted(s, wchar_t('"'), escape );
-    assert ( s == p );
-    }
-
-
-std::wstring quote ( const wchar_t *p, wchar_t delim='"', wchar_t escape='\\' ) {
-    std::wstringstream ss;
-    ss << std::quoted(p, delim, escape);
-    std::wstring s;
-    ss >> s;    // no quote
-    return s;
-}
-
-std::wstring unquote ( const wchar_t *p, wchar_t delim='"', wchar_t escape='\\' ) {
-    std::wstringstream ss;
-    ss << p;
-    std::wstring s;
-    ss >> std::quoted(s, delim, escape);
-    return s;
-}
-
 int main()
 {
     both_ways ( "" );   // This is a compilation check
@@ -170,31 +131,31 @@ int main()
     round_trip_ws (  "" );
     round_trip_d  (  "", 'q' );
     round_trip_e  (  "", 'q' );
-    
+
     round_trip    ( L"" );
     round_trip_ws ( L"" );
     round_trip_d  ( L"", 'q' );
     round_trip_e  ( L"", 'q' );
-    
+
     round_trip    (  "Hi" );
     round_trip_ws (  "Hi" );
     round_trip_d  (  "Hi", '!' );
     round_trip_e  (  "Hi", '!' );
     assert ( quote ( "Hi", '!' ) == "!Hi!" );
     assert ( quote ( "Hi!", '!' ) == R"(!Hi\!!)" );
-    
+
     round_trip    ( L"Hi" );
     round_trip_ws ( L"Hi" );
     round_trip_d  ( L"Hi", '!' );
     round_trip_e  ( L"Hi", '!' );
     assert ( quote ( L"Hi", '!' )  == L"!Hi!" );
     assert ( quote ( L"Hi!", '!' ) == LR"(!Hi\!!)" );
-    
+
     round_trip    (  "Hi Mom" );
     round_trip_ws (  "Hi Mom" );
     round_trip    ( L"Hi Mom" );
     round_trip_ws ( L"Hi Mom" );
-    
+
     assert ( quote (  "" )  ==  "\"\"" );
     assert ( quote ( L"" )  == L"\"\"" );
     assert ( quote (  "a" ) ==  "\"a\"" );
@@ -203,7 +164,7 @@ int main()
 //  missing end quote - must not hang
     assert ( unquote (  "\"abc" ) ==  "abc" );
     assert ( unquote ( L"\"abc" ) == L"abc" );
-    
+
     assert ( unquote (  "abc" ) == "abc" ); // no delimiter
     assert ( unquote ( L"abc" ) == L"abc" ); // no delimiter
     assert ( unquote (  "abc def" ) ==  "abc" ); // no delimiter
diff --git a/test/std/input.output/iostream.format/quoted.manip/quoted_char.fail.cpp b/test/std/input.output/iostream.format/quoted.manip/quoted_char.fail.cpp
index 2f516f8fbc91..c9fccea2c7d0 100644
--- a/test/std/input.output/iostream.format/quoted.manip/quoted_char.fail.cpp
+++ b/test/std/input.output/iostream.format/quoted.manip/quoted_char.fail.cpp
@@ -16,7 +16,11 @@
 #include <string>
 #include <cassert>
 
-#if _LIBCPP_STD_VER > 11
+#include "test_macros.h"
+
+//	Test that mismatches between strings and wides streams are diagnosed
+
+#if TEST_STD_VER > 11
 
 void round_trip ( const char *p ) {
     std::wstringstream ss;
@@ -29,7 +33,7 @@ void round_trip ( const char *p ) {
 
 int main()
 {
-    round_trip ( "Hi Mom" );   
+    round_trip ( "Hi Mom" );
 }
 #else
 #error
diff --git a/test/std/input.output/iostream.format/quoted.manip/quoted_traits.fail.cpp b/test/std/input.output/iostream.format/quoted.manip/quoted_traits.fail.cpp
index bdd362df19c9..109674d1660d 100644
--- a/test/std/input.output/iostream.format/quoted.manip/quoted_traits.fail.cpp
+++ b/test/std/input.output/iostream.format/quoted.manip/quoted_traits.fail.cpp
@@ -16,7 +16,11 @@
 #include <string>
 #include <cassert>
 
-#if _LIBCPP_STD_VER > 11
+#include "test_macros.h"
+
+#if TEST_STD_VER > 11
+
+//	Test that mismatches in the traits between the quoted object and the dest string are diagnosed.
 
 template <class charT>
 struct test_traits
@@ -35,7 +39,7 @@ void round_trip ( const char *p ) {
 
 int main()
 {
-    round_trip ( "Hi Mom" );   
+    round_trip ( "Hi Mom" );
 }
 #else
 #error
diff --git a/test/std/input.output/iostreams.base/ios/basic.ios.members/move.pass.cpp b/test/std/input.output/iostreams.base/ios/basic.ios.members/move.pass.cpp
index 509b836686c5..0b068e0d4a9f 100644
--- a/test/std/input.output/iostreams.base/ios/basic.ios.members/move.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/basic.ios.members/move.pass.cpp
@@ -41,17 +41,17 @@ bool g1_called = false;
 bool g2_called = false;
 bool g3_called = false;
 
-void f1(std::ios_base::event ev, std::ios_base& stream, int index)
+void f1(std::ios_base::event, std::ios_base&, int)
 {
     f1_called = true;
 }
 
-void f2(std::ios_base::event ev, std::ios_base& stream, int index)
+void f2(std::ios_base::event, std::ios_base&, int)
 {
     f2_called = true;
 }
 
-void g1(std::ios_base::event ev, std::ios_base& stream, int index)
+void g1(std::ios_base::event ev, std::ios_base&, int index)
 {
     if (ev == std::ios_base::imbue_event)
     {
@@ -60,7 +60,7 @@ void g1(std::ios_base::event ev, std::ios_base& stream, int index)
     }
 }
 
-void g2(std::ios_base::event ev, std::ios_base& stream, int index)
+void g2(std::ios_base::event ev, std::ios_base&, int index)
 {
     if (ev == std::ios_base::imbue_event)
     {
@@ -69,7 +69,7 @@ void g2(std::ios_base::event ev, std::ios_base& stream, int index)
     }
 }
 
-void g3(std::ios_base::event ev, std::ios_base& stream, int index)
+void g3(std::ios_base::event ev, std::ios_base&, int index)
 {
     if (ev == std::ios_base::imbue_event)
     {
diff --git a/test/std/input.output/iostreams.base/ios/basic.ios.members/narow.pass.cpp b/test/std/input.output/iostreams.base/ios/basic.ios.members/narrow.pass.cpp
index bf865e68149d..bf865e68149d 100644
--- a/test/std/input.output/iostreams.base/ios/basic.ios.members/narow.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/basic.ios.members/narrow.pass.cpp
diff --git a/test/std/input.output/iostreams.base/ios/basic.ios.members/swap.pass.cpp b/test/std/input.output/iostreams.base/ios/basic.ios.members/swap.pass.cpp
index e44f4b32512c..2887ca100c99 100644
--- a/test/std/input.output/iostreams.base/ios/basic.ios.members/swap.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/basic.ios.members/swap.pass.cpp
@@ -41,31 +41,31 @@ bool g1_called = false;
 bool g2_called = false;
 bool g3_called = false;
 
-void f1(std::ios_base::event ev, std::ios_base& stream, int index)
+void f1(std::ios_base::event, std::ios_base&, int index)
 {
     assert(index == 4);
     f1_called = true;
 }
 
-void f2(std::ios_base::event ev, std::ios_base& stream, int index)
+void f2(std::ios_base::event, std::ios_base&, int index)
 {
     assert(index == 5);
     f2_called = true;
 }
 
-void g1(std::ios_base::event ev, std::ios_base& stream, int index)
+void g1(std::ios_base::event, std::ios_base&, int index)
 {
     assert(index == 7);
     g1_called = true;
 }
 
-void g2(std::ios_base::event ev, std::ios_base& stream, int index)
+void g2(std::ios_base::event, std::ios_base&, int index)
 {
     assert(index == 8);
     g2_called = true;
 }
 
-void g3(std::ios_base::event ev, std::ios_base& stream, int index)
+void g3(std::ios_base::event, std::ios_base&, int index)
 {
     assert(index == 9);
     g3_called = true;
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sgetn.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sgetn.pass.cpp
index 730cedeea76c..1935308dea0f 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sgetn.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sgetn.pass.cpp
@@ -25,7 +25,7 @@ struct test
     test() {}
 
 protected:
-    std::streamsize xsgetn(char_type* s, std::streamsize n)
+    std::streamsize xsgetn(char_type*, std::streamsize)
     {
         ++xsgetn_called;
         return 10;
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.pback/sputbackc.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.pback/sputbackc.pass.cpp
index 34a2a2dda372..2f4aad051079 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.pback/sputbackc.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.pback/sputbackc.pass.cpp
@@ -32,7 +32,7 @@ struct test
     }
 
 protected:
-    int_type pbackfail(int_type c = traits_type::eof())
+    int_type pbackfail(int_type = traits_type::eof())
     {
         ++pbackfail_called;
         return 'a';
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.pback/sungetc.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.pback/sungetc.pass.cpp
index 4c68fada07a8..36a19da85fe0 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.pback/sungetc.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.pback/sungetc.pass.cpp
@@ -32,7 +32,7 @@ struct test
     }
 
 protected:
-    int_type pbackfail(int_type c = traits_type::eof())
+    int_type pbackfail(int_type = traits_type::eof())
     {
         ++pbackfail_called;
         return 'a';
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.put/sputc.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.put/sputc.pass.cpp
index b04b8b0acc91..5ea48c18d793 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.put/sputc.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.put/sputc.pass.cpp
@@ -36,7 +36,7 @@ struct test
     }
 
 protected:
-    int_type overflow(int_type c = traits_type::eof())
+    int_type overflow(int_type = traits_type::eof())
     {
         ++overflow_called;
         return 'a';
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.put/sputn.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.put/sputn.pass.cpp
index e03e8e0cbda3..4ced690a2652 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.put/sputn.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.put/sputn.pass.cpp
@@ -25,7 +25,7 @@ struct test
     test() {}
 
 protected:
-    std::streamsize xsputn(const char_type* s, std::streamsize n)
+    std::streamsize xsputn(const char_type*, std::streamsize)
     {
         ++xsputn_called;
         return 5;
diff --git a/test/std/iterators/iterator.container/data.pass.cpp b/test/std/iterators/iterator.container/data.pass.cpp
index 3d1fa33358db..a7a17480235a 100644
--- a/test/std/iterators/iterator.container/data.pass.cpp
+++ b/test/std/iterators/iterator.container/data.pass.cpp
@@ -13,7 +13,9 @@
 // template <class T, size_t N> constexpr T* data(T (&array)[N]) noexcept;           // C++17
 // template <class E> constexpr const E* data(initializer_list<E> il) noexcept;      // C++17
 
-#if __cplusplus <= 201402L
+#include "test_macros.h"
+
+#if TEST_STD_VER <= 14
 int main () {}
 #else
 
@@ -40,7 +42,7 @@ void test_container( C& c )
 {
     assert ( std::data(c)   == c.data());
 }
-    
+
 template<typename T>
 void test_container( std::initializer_list<T>& c)
 {
@@ -58,7 +60,7 @@ int main()
     std::vector<int> v; v.push_back(1);
     std::array<int, 1> a; a[0] = 3;
     std::initializer_list<int> il = { 4 };
-    
+
     test_container ( v );
     test_container ( a );
     test_container ( il );
@@ -66,7 +68,7 @@ int main()
     test_const_container ( v );
     test_const_container ( a );
     test_const_container ( il );
-    
+
     static constexpr int arrA [] { 1, 2, 3 };
     test_const_array ( arrA );
 }
diff --git a/test/std/iterators/iterator.container/empty.pass.cpp b/test/std/iterators/iterator.container/empty.pass.cpp
index f26cb98e1aed..f9b8b94a89f9 100644
--- a/test/std/iterators/iterator.container/empty.pass.cpp
+++ b/test/std/iterators/iterator.container/empty.pass.cpp
@@ -12,7 +12,9 @@
 // template <class T, size_t N> constexpr bool empty(const T (&array)[N]) noexcept;  // C++17
 // template <class E> constexpr bool empty(initializer_list<E> il) noexcept;         // C++17
 
-#if __cplusplus <= 201402L
+#include "test_macros.h"
+
+#if TEST_STD_VER <= 14
 int main () {}
 #else
 
@@ -40,7 +42,7 @@ void test_container( C& c )
 {
     assert ( std::empty(c)   == c.empty());
 }
-    
+
 template<typename T>
 void test_container( std::initializer_list<T>& c )
 {
@@ -59,7 +61,7 @@ int main()
     std::list<int>   l; l.push_back(2);
     std::array<int, 1> a; a[0] = 3;
     std::initializer_list<int> il = { 4 };
-    
+
     test_container ( v );
     test_container ( l );
     test_container ( a );
@@ -69,7 +71,7 @@ int main()
     test_const_container ( l );
     test_const_container ( a );
     test_const_container ( il );
-    
+
     static constexpr int arrA [] { 1, 2, 3 };
     test_const_array ( arrA );
 }
diff --git a/test/std/iterators/iterator.container/size.pass.cpp b/test/std/iterators/iterator.container/size.pass.cpp
index 705fb40e1926..87b0ef897072 100644
--- a/test/std/iterators/iterator.container/size.pass.cpp
+++ b/test/std/iterators/iterator.container/size.pass.cpp
@@ -11,7 +11,9 @@
 // template <class C> constexpr auto size(const C& c) -> decltype(c.size());         // C++17
 // template <class T, size_t N> constexpr size_t size(const T (&array)[N]) noexcept; // C++17
 
-#if __cplusplus <= 201402L
+#include "test_macros.h"
+
+#if TEST_STD_VER <= 14
 int main () {}
 #else
 
@@ -39,7 +41,7 @@ void test_container( C& c)
 {
     assert ( std::size(c)   == c.size());
 }
-    
+
 template<typename T>
 void test_container( std::initializer_list<T>& c )
 {
@@ -58,7 +60,7 @@ int main()
     std::list<int>   l; l.push_back(2);
     std::array<int, 1> a; a[0] = 3;
     std::initializer_list<int> il = { 4 };
-    
+
     test_container ( v );
     test_container ( l );
     test_container ( a );
@@ -68,7 +70,7 @@ int main()
     test_const_container ( l );
     test_const_container ( a );
     test_const_container ( il );
-    
+
     static constexpr int arrA [] { 1, 2, 3 };
     test_const_array ( arrA );
 }
diff --git a/test/std/iterators/iterator.primitives/std.iterator.tags/bidirectional_iterator_tag.pass.cpp b/test/std/iterators/iterator.primitives/std.iterator.tags/bidirectional_iterator_tag.pass.cpp
index 0f368c3b765f..ecda1d146949 100644
--- a/test/std/iterators/iterator.primitives/std.iterator.tags/bidirectional_iterator_tag.pass.cpp
+++ b/test/std/iterators/iterator.primitives/std.iterator.tags/bidirectional_iterator_tag.pass.cpp
@@ -17,6 +17,7 @@
 int main()
 {
     std::bidirectional_iterator_tag tag;
+    ((void)tag); // Prevent unused warning
     static_assert((std::is_base_of<std::forward_iterator_tag,
                                    std::bidirectional_iterator_tag>::value), "");
     static_assert((!std::is_base_of<std::output_iterator_tag,
diff --git a/test/std/iterators/iterator.primitives/std.iterator.tags/forward_iterator_tag.pass.cpp b/test/std/iterators/iterator.primitives/std.iterator.tags/forward_iterator_tag.pass.cpp
index 0936595c85d6..e11b8e9ba7ac 100644
--- a/test/std/iterators/iterator.primitives/std.iterator.tags/forward_iterator_tag.pass.cpp
+++ b/test/std/iterators/iterator.primitives/std.iterator.tags/forward_iterator_tag.pass.cpp
@@ -17,6 +17,7 @@
 int main()
 {
     std::forward_iterator_tag tag;
+    ((void)tag); // Prevent unused warning
     static_assert((std::is_base_of<std::input_iterator_tag,
                                    std::forward_iterator_tag>::value), "");
     static_assert((!std::is_base_of<std::output_iterator_tag,
diff --git a/test/std/iterators/iterator.primitives/std.iterator.tags/input_iterator_tag.pass.cpp b/test/std/iterators/iterator.primitives/std.iterator.tags/input_iterator_tag.pass.cpp
index afeac3e91cae..19b517c328e7 100644
--- a/test/std/iterators/iterator.primitives/std.iterator.tags/input_iterator_tag.pass.cpp
+++ b/test/std/iterators/iterator.primitives/std.iterator.tags/input_iterator_tag.pass.cpp
@@ -17,6 +17,7 @@
 int main()
 {
     std::input_iterator_tag tag;
+    ((void)tag); // Prevent unused warning
     static_assert((!std::is_base_of<std::output_iterator_tag,
                                     std::input_iterator_tag>::value), "");
 }
diff --git a/test/std/iterators/iterator.primitives/std.iterator.tags/output_iterator_tag.pass.cpp b/test/std/iterators/iterator.primitives/std.iterator.tags/output_iterator_tag.pass.cpp
index 7f7f66a98f4a..e315b2724f82 100644
--- a/test/std/iterators/iterator.primitives/std.iterator.tags/output_iterator_tag.pass.cpp
+++ b/test/std/iterators/iterator.primitives/std.iterator.tags/output_iterator_tag.pass.cpp
@@ -17,6 +17,7 @@
 int main()
 {
     std::output_iterator_tag tag;
+    ((void)tag); // Prevent unused warning
     static_assert((!std::is_base_of<std::input_iterator_tag,
                                     std::output_iterator_tag>::value), "");
 }
diff --git a/test/std/iterators/iterator.primitives/std.iterator.tags/random_access_iterator_tag.pass.cpp b/test/std/iterators/iterator.primitives/std.iterator.tags/random_access_iterator_tag.pass.cpp
index 04f830bc3109..f16a3b74c53f 100644
--- a/test/std/iterators/iterator.primitives/std.iterator.tags/random_access_iterator_tag.pass.cpp
+++ b/test/std/iterators/iterator.primitives/std.iterator.tags/random_access_iterator_tag.pass.cpp
@@ -17,6 +17,7 @@
 int main()
 {
     std::random_access_iterator_tag tag;
+    ((void)tag); // Prevent unused warning
     static_assert((std::is_base_of<std::bidirectional_iterator_tag,
                                    std::random_access_iterator_tag>::value), "");
     static_assert((!std::is_base_of<std::output_iterator_tag,
diff --git a/test/std/iterators/iterator.range/begin-end.pass.cpp b/test/std/iterators/iterator.range/begin-end.pass.cpp
index bd7e0aa90fbc..ec3f61789b27 100644
--- a/test/std/iterators/iterator.range/begin-end.pass.cpp
+++ b/test/std/iterators/iterator.range/begin-end.pass.cpp
@@ -15,7 +15,9 @@
 // template <class E> reverse_iterator<const E*> rbegin(initializer_list<E> il);
 // template <class E> reverse_iterator<const E*> rend(initializer_list<E> il);
 
-#if __cplusplus >= 201103L
+#include "test_macros.h"
+
+#if TEST_STD_VER >= 11
 #include <iterator>
 #include <cassert>
 #include <vector>
@@ -81,7 +83,7 @@ void test_container( C & c, typename C::value_type val ) {
     assert ( std::crend(c)   == c.crend());
 #endif
     }
-    
+
 template<typename T>
 void test_container( std::initializer_list<T> & c, T val ) {
     assert ( std::begin(c)   == c.begin());
@@ -121,7 +123,7 @@ int main(){
     std::list<int> l;   l.push_back(2);
     std::array<int, 1> a; a[0] = 3;
     std::initializer_list<int> il = { 4 };
-    
+
     test_container ( v, 1 );
     test_container ( l, 2 );
     test_container ( a, 3 );
@@ -131,7 +133,7 @@ int main(){
     test_const_container ( l, 2 );
     test_const_container ( a, 3 );
     test_const_container ( il, 4 );
-    
+
     static constexpr int arrA [] { 1, 2, 3 };
     test_const_array ( arrA );
 #if _LIBCPP_STD_VER > 11
diff --git a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iterator/types.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iterator/types.pass.cpp
index 2611c9a4b0cc..7aa7f3443aa4 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iterator/types.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iterator/types.pass.cpp
@@ -21,7 +21,7 @@
 //   typedef Cont                        container_type;
 //   typedef void                        value_type;
 //   typedef void                        difference_type;
-//   typedef back_insert_iterator<Cont>& reference;
+//   typedef void                        reference;
 //   typedef void                        pointer;
 // };
 
@@ -48,7 +48,7 @@ test()
     static_assert((std::is_same<typename R::container_type, C>::value), "");
     static_assert((std::is_same<typename R::value_type, void>::value), "");
     static_assert((std::is_same<typename R::difference_type, void>::value), "");
-    static_assert((std::is_same<typename R::reference, R&>::value), "");
+    static_assert((std::is_same<typename R::reference, void>::value), "");
     static_assert((std::is_same<typename R::pointer, void>::value), "");
     static_assert((std::is_same<typename R::iterator_category, std::output_iterator_tag>::value), "");
 }
diff --git a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iterator/types.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iterator/types.pass.cpp
index 755133a91948..7a7c678edaaf 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iterator/types.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iterator/types.pass.cpp
@@ -21,7 +21,7 @@
 //   typedef Container                   container_type;
 //   typedef void                        value_type;
 //   typedef void                        difference_type;
-//   typedef front_insert_iterator<Cont>& reference;
+//   typedef void                        reference;
 //   typedef void                        pointer;
 //   typedef output_iterator_tag         iterator_category;
 // };
@@ -49,7 +49,7 @@ test()
     static_assert((std::is_same<typename R::container_type, C>::value), "");
     static_assert((std::is_same<typename R::value_type, void>::value), "");
     static_assert((std::is_same<typename R::difference_type, void>::value), "");
-    static_assert((std::is_same<typename R::reference, R&>::value), "");
+    static_assert((std::is_same<typename R::reference, void>::value), "");
     static_assert((std::is_same<typename R::pointer, void>::value), "");
     static_assert((std::is_same<typename R::iterator_category, std::output_iterator_tag>::value), "");
 }
diff --git a/test/std/iterators/predef.iterators/insert.iterators/insert.iterator/types.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/insert.iterator/types.pass.cpp
index cf63df63e89b..5b61a3895132 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/insert.iterator/types.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/insert.iterator/types.pass.cpp
@@ -22,7 +22,7 @@
 //   typedef Cont                   container_type;
 //   typedef void                   value_type;
 //   typedef void                   difference_type;
-//   typedef insert_iterator<Cont>& reference;
+//   typedef void                   reference;
 //   typedef void                   pointer;
 // };
 
@@ -53,7 +53,7 @@ test()
     static_assert((std::is_same<typename R::container_type, C>::value), "");
     static_assert((std::is_same<typename R::value_type, void>::value), "");
     static_assert((std::is_same<typename R::difference_type, void>::value), "");
-    static_assert((std::is_same<typename R::reference, R&>::value), "");
+    static_assert((std::is_same<typename R::reference, void>::value), "");
     static_assert((std::is_same<typename R::pointer, void>::value), "");
     static_assert((std::is_same<typename R::iterator_category, std::output_iterator_tag>::value), "");
 }
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp
index 9bdf7215e9ee..a6d4d61e13ce 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp
@@ -18,7 +18,7 @@
 // public:
 //   typedef Iter                  iterator_type;
 //   typedef Iter::difference_type difference_type;
-//   typedef Iterator              pointer;
+//   typedef Iter                  pointer;
 //   typedef Iter::value_type      value_type;
 //   typedef value_type&&          reference;
 // };
@@ -26,8 +26,18 @@
 #include <iterator>
 #include <type_traits>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
+template <class ValueType, class Reference>
+struct DummyIt {
+  typedef std::forward_iterator_tag iterator_category;
+  typedef ValueType value_type;
+  typedef std::ptrdiff_t difference_type;
+  typedef ValueType* pointer;
+  typedef Reference reference;
+};
+
 template <class It>
 void
 test()
@@ -36,9 +46,9 @@ test()
     typedef std::iterator_traits<It> T;
     static_assert((std::is_same<typename R::iterator_type, It>::value), "");
     static_assert((std::is_same<typename R::difference_type, typename T::difference_type>::value), "");
-    static_assert((std::is_same<typename R::pointer, typename T::pointer>::value), "");
+    static_assert((std::is_same<typename R::pointer, It>::value), "");
     static_assert((std::is_same<typename R::value_type, typename T::value_type>::value), "");
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#if TEST_STD_VER >= 11
     static_assert((std::is_same<typename R::reference, typename R::value_type&&>::value), "");
 #else
     static_assert((std::is_same<typename R::reference, typename T::reference>::value), "");
@@ -53,4 +63,33 @@ int main()
     test<bidirectional_iterator<char*> >();
     test<random_access_iterator<char*> >();
     test<char*>();
+#if TEST_STD_VER >= 11
+    {
+        typedef DummyIt<int, int> T;
+        typedef std::move_iterator<T> It;
+        static_assert(std::is_same<It::reference, int>::value, "");
+    }
+    {
+        typedef DummyIt<int, std::reference_wrapper<int> > T;
+        typedef std::move_iterator<T> It;
+        static_assert(std::is_same<It::reference, std::reference_wrapper<int> >::value, "");
+    }
+    {
+        // Check that move_iterator uses whatever reference type it's given
+        // when it's not a reference.
+        typedef DummyIt<int, long > T;
+        typedef std::move_iterator<T> It;
+        static_assert(std::is_same<It::reference, long>::value, "");
+    }
+    {
+        typedef DummyIt<int, int&> T;
+        typedef std::move_iterator<T> It;
+        static_assert(std::is_same<It::reference, int&&>::value, "");
+    }
+    {
+        typedef DummyIt<int, int&&> T;
+        typedef std::move_iterator<T> It;
+        static_assert(std::is_same<It::reference, int&&>::value, "");
+    }
+#endif
 }
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.make/make_reverse_iterator.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.make/make_reverse_iterator.pass.cpp
index 98b7331cd386..7ec287e5cd37 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.make/make_reverse_iterator.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.make/make_reverse_iterator.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <iterator>
 
 // reverse_iterator
@@ -19,8 +20,6 @@
 
 #include "test_iterators.h"
 
-#if _LIBCPP_STD_VER > 11
-
 template <class It>
 void
 test(It i)
@@ -37,6 +36,4 @@ int main()
     while ( b != e )
         test ( b++ );
 }
-#else
-int main () {}
-#endif
+
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opref/op_arrow.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opref/op_arrow.pass.cpp
index efbdf1406c96..404e8fbf19bf 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opref/op_arrow.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opref/op_arrow.pass.cpp
@@ -63,13 +63,13 @@ int main()
 {
     A a;
     test(&a+1, A());
-    
+
     {
     std::list<B> l;
     l.push_back(B(0));
     l.push_back(B(1));
     l.push_back(B(2));
-    
+
     {
     std::list<B>::const_iterator i = l.begin();
     assert ( i->get() == 0 );  ++i;
@@ -77,7 +77,7 @@ int main()
     assert ( i->get() == 2 );  ++i;
     assert ( i == l.end ());
     }
-    
+
     {
     std::list<B>::const_reverse_iterator ri = l.rbegin();
     assert ( ri->get() == 2 );  ++ri;
diff --git a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.fail.cpp b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.fail.cpp
index 5e6cc5455998..452049677c75 100644
--- a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.fail.cpp
+++ b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.fail.cpp
@@ -16,11 +16,13 @@
 #include <iterator>
 #include <cassert>
 
-struct S { S(); }; // not constexpr 
+#include "test_macros.h"
+
+struct S { S(); }; // not constexpr
 
 int main()
 {
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     constexpr std::istream_iterator<S> it;
     }
diff --git a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.pass.cpp b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.pass.cpp
index bea07ec2272e..c1924e4b9272 100644
--- a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.pass.cpp
+++ b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.pass.cpp
@@ -16,15 +16,17 @@
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
     {
     typedef std::istream_iterator<int> T;
     T it;
     assert(it == T());
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     constexpr T it2;
 #endif
     }
-    
+
 }
diff --git a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/arrow.pass.cpp b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/arrow.pass.cpp
index 5c4ddcad32ea..30057a227c99 100644
--- a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/arrow.pass.cpp
+++ b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/arrow.pass.cpp
@@ -23,6 +23,8 @@ struct A
     int i_;
 };
 
+void operator&(A const&) {}
+
 std::istream& operator>>(std::istream& is, A& a)
 {
     return is >> a.d_ >> a.i_;
diff --git a/test/std/iterators/stream.iterators/istream.iterator/types.pass.cpp b/test/std/iterators/stream.iterators/istream.iterator/types.pass.cpp
index 85a70a017976..1250e364d35e 100644
--- a/test/std/iterators/stream.iterators/istream.iterator/types.pass.cpp
+++ b/test/std/iterators/stream.iterators/istream.iterator/types.pass.cpp
@@ -9,6 +9,9 @@
 
 // <iterator>
 
+// Test fails due to use of is_trivially_* trait.
+// XFAIL: gcc-4.9
+
 // template <class T, class charT = char, class traits = char_traits<charT>,
 //           class Distance = ptrdiff_t>
 // class istream_iterator
diff --git a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/default.pass.cpp b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/default.pass.cpp
index 46ac390d931f..74aa6f2ab517 100644
--- a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/default.pass.cpp
+++ b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/default.pass.cpp
@@ -13,20 +13,22 @@
 //
 // istreambuf_iterator() throw();
 //
-// All specializations of istreambuf_iterator shall have a trivial copy constructor, 
+// All specializations of istreambuf_iterator shall have a trivial copy constructor,
 //    a constexpr default constructor and a trivial destructor.
 
 #include <iterator>
 #include <sstream>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
     {
         typedef std::istreambuf_iterator<char> T;
         T it;
         assert(it == T());
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
         constexpr T it2;
 #endif
     }
@@ -34,7 +36,7 @@ int main()
         typedef std::istreambuf_iterator<wchar_t> T;
         T it;
         assert(it == T());
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
         constexpr T it2;
 #endif
     }
diff --git a/test/std/iterators/stream.iterators/istreambuf.iterator/types.pass.cpp b/test/std/iterators/stream.iterators/istreambuf.iterator/types.pass.cpp
index 2ad927cf952c..c974e2cd091d 100644
--- a/test/std/iterators/stream.iterators/istreambuf.iterator/types.pass.cpp
+++ b/test/std/iterators/stream.iterators/istreambuf.iterator/types.pass.cpp
@@ -9,6 +9,9 @@
 
 // <iterator>
 
+// Test fails due to use of is_trivially_* trait.
+// XFAIL: gcc-4.9
+
 // template<class charT, class traits = char_traits<charT> >
 // class istreambuf_iterator
 //     : public iterator<input_iterator_tag, charT,
@@ -23,19 +26,23 @@
 //     typedef basic_istream<charT,traits>   istream_type;
 //     ...
 //
-// All specializations of istreambuf_iterator shall have a trivial copy constructor, 
+// All specializations of istreambuf_iterator shall have a trivial copy constructor,
 //    a constexpr default constructor and a trivial destructor.
 
 #include <iterator>
 #include <string>
 #include <type_traits>
 
+#include "test_macros.h"
+
 int main()
 {
     typedef std::istreambuf_iterator<char> I1;
-    static_assert((std::is_convertible<I1,
-        std::iterator<std::input_iterator_tag, char, std::char_traits<char>::off_type,
-        char*, char> >::value), "");
+    static_assert((std::is_same<I1::iterator_category, std::input_iterator_tag>::value), "");
+    static_assert((std::is_same<I1::value_type, char>::value), "");
+    static_assert((std::is_same<I1::difference_type, std::char_traits<char>::off_type>::value), "");
+    LIBCPP_STATIC_ASSERT((std::is_same<I1::pointer, char*>::value), "");
+    static_assert((std::is_same<I1::reference, char>::value), "");
     static_assert((std::is_same<I1::char_type, char>::value), "");
     static_assert((std::is_same<I1::traits_type, std::char_traits<char> >::value), "");
     static_assert((std::is_same<I1::int_type, I1::traits_type::int_type>::value), "");
@@ -46,9 +53,11 @@ int main()
     static_assert((std::is_trivially_destructible<I1>::value), "" );
 
     typedef std::istreambuf_iterator<wchar_t> I2;
-    static_assert((std::is_convertible<I2,
-        std::iterator<std::input_iterator_tag, wchar_t, std::char_traits<wchar_t>::off_type,
-        wchar_t*, wchar_t> >::value), "");
+    static_assert((std::is_same<I2::iterator_category, std::input_iterator_tag>::value), "");
+    static_assert((std::is_same<I2::value_type, wchar_t>::value), "");
+    static_assert((std::is_same<I2::difference_type, std::char_traits<wchar_t>::off_type>::value), "");
+    LIBCPP_STATIC_ASSERT((std::is_same<I2::pointer, wchar_t*>::value), "");
+    static_assert((std::is_same<I2::reference, wchar_t>::value), "");
     static_assert((std::is_same<I2::char_type, wchar_t>::value), "");
     static_assert((std::is_same<I2::traits_type, std::char_traits<wchar_t> >::value), "");
     static_assert((std::is_same<I2::int_type, I2::traits_type::int_type>::value), "");
diff --git a/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/ostream.pass.cpp b/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/ostream.pass.cpp
index 321cfbdb82c8..6366355cc108 100644
--- a/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/ostream.pass.cpp
+++ b/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/ostream.pass.cpp
@@ -17,9 +17,23 @@
 #include <sstream>
 #include <cassert>
 
+struct MyTraits : std::char_traits<char> {};
+
+typedef std::basic_ostringstream<char, MyTraits> StringStream;
+typedef std::basic_ostream<char, MyTraits> BasicStream;
+
+void operator&(BasicStream const&) {}
+
 int main()
 {
-    std::ostringstream outf;
-    std::ostream_iterator<int> i(outf);
-    assert(outf.good());
+    {
+        std::ostringstream outf;
+        std::ostream_iterator<int> i(outf);
+        assert(outf.good());
+    }
+    {
+        StringStream outf;
+        std::ostream_iterator<int, char, MyTraits> i(outf);
+        assert(outf.good());
+    }
 }
diff --git a/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/ostream_delem.pass.cpp b/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/ostream_delim.pass.cpp
index 8e5c771a4ab4..69c2dfc9b5f2 100644
--- a/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/ostream_delem.pass.cpp
+++ b/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/ostream_delim.pass.cpp
@@ -17,6 +17,14 @@
 #include <sstream>
 #include <cassert>
 
+
+struct MyTraits : std::char_traits<char> {};
+
+typedef std::basic_ostringstream<char, MyTraits> StringStream;
+typedef std::basic_ostream<char, MyTraits> BasicStream;
+
+void operator&(BasicStream const&) {}
+
 int main()
 {
     {
@@ -29,4 +37,9 @@ int main()
         std::ostream_iterator<double, wchar_t> i(outf, L", ");
         assert(outf.good());
     }
+    {
+        StringStream outf;
+        std::ostream_iterator<int, char, MyTraits> i(outf, ", ");
+        assert(outf.good());
+    }
 }
diff --git a/test/std/language.support/cstdint/cstdint.syn/cstdint.pass.cpp b/test/std/language.support/cstdint/cstdint.syn/cstdint.pass.cpp
index 23cf8b66bcb1..20ae6e620753 100644
--- a/test/std/language.support/cstdint/cstdint.syn/cstdint.pass.cpp
+++ b/test/std/language.support/cstdint/cstdint.syn/cstdint.pass.cpp
@@ -172,8 +172,8 @@ int main()
     // INTN_MIN
     static_assert(INT8_MIN == -128, "INT8_MIN == -128");
     static_assert(INT16_MIN == -32768, "INT16_MIN == -32768");
-    static_assert(INT32_MIN == -2147483648U, "INT32_MIN == -2147483648");
-    static_assert(INT64_MIN == -9223372036854775808ULL, "INT64_MIN == -9223372036854775808LL");
+    static_assert(INT32_MIN == -2147483647 - 1, "INT32_MIN == -2147483648");
+    static_assert(INT64_MIN == -9223372036854775807LL - 1, "INT64_MIN == -9223372036854775808LL");
 
     // INTN_MAX
     static_assert(INT8_MAX == 127, "INT8_MAX == 127");
@@ -190,8 +190,8 @@ int main()
     // INT_FASTN_MIN
     static_assert(INT_FAST8_MIN <= -128, "INT_FAST8_MIN <= -128");
     static_assert(INT_FAST16_MIN <= -32768, "INT_FAST16_MIN <= -32768");
-    static_assert(INT_FAST32_MIN <= -2147483648U, "INT_FAST32_MIN <= -2147483648");
-    static_assert(INT_FAST64_MIN <= -9223372036854775808ULL, "INT_FAST64_MIN <= -9223372036854775808LL");
+    static_assert(INT_FAST32_MIN <= -2147483647 - 1, "INT_FAST32_MIN <= -2147483648");
+    static_assert(INT_FAST64_MIN <= -9223372036854775807LL - 1, "INT_FAST64_MIN <= -9223372036854775808LL");
 
     // INT_FASTN_MAX
     static_assert(INT_FAST8_MAX >= 127, "INT_FAST8_MAX >= 127");
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow_replace.pass.cpp
index 105c7a93f210..5887bb0bdf30 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow_replace.pass.cpp
@@ -11,6 +11,10 @@
 
 // UNSUPPORTED: sanitizer-new-delete
 
+// TODO Investigate why UBSAN prevents new from calling our replacement.
+// XFAIL: ubsan
+
+
 #include <new>
 #include <cstddef>
 #include <cstdlib>
@@ -22,7 +26,9 @@ int new_called = 0;
 void* operator new(std::size_t s) throw(std::bad_alloc)
 {
     ++new_called;
-    return std::malloc(s);
+    void* ret = std::malloc(s);
+    if (!ret) std::abort(); // placate MSVC's unchecked malloc warning
+    return  ret;
 }
 
 void  operator delete(void* p) throw()
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_replace.pass.cpp
index 92bd7b952dcb..1e78ea8fe267 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_replace.pass.cpp
@@ -11,6 +11,10 @@
 
 // UNSUPPORTED: sanitizer-new-delete
 
+// TODO Investigate why UBSAN prevents new from calling our replacement.
+// XFAIL: ubsan
+
+
 #include <new>
 #include <cstddef>
 #include <cstdlib>
@@ -22,7 +26,9 @@ volatile int new_called = 0;
 void* operator new(std::size_t s) throw(std::bad_alloc)
 {
     ++new_called;
-    return std::malloc(s);
+    void* ret = std::malloc(s);
+    if (!ret) std::abort(); // placate MSVC's unchecked malloc warning
+    return  ret;
 }
 
 void  operator delete(void* p) throw()
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_array.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_array.pass.cpp
index 1ab52ae4c8df..462d1973c507 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_array.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_array.pass.cpp
@@ -22,9 +22,13 @@ struct A
 
 int main()
 {
-    char buf[3*sizeof(A)];
+    const std::size_t Size = 3;
+    // placement new might require additional space.
+    const std::size_t ExtraSize = 64;
+    char buf[Size*sizeof(A) + ExtraSize];
 
-    A* ap = new(buf) A[3];
-    assert((char*)ap == buf);
-    assert(A_constructed == 3);
+    A* ap = new(buf) A[Size];
+    assert((char*)ap >= buf);
+    assert((char*)ap < (buf + ExtraSize));
+    assert(A_constructed == Size);
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new.pass.cpp
index 57ce28752208..892842a1b9f4 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new.pass.cpp
@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // XFAIL: libcpp-no-exceptions
+
 // test operator new
 
 // asan and msan will not call the new handler.
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow_replace.pass.cpp
index cd70f90948d2..eb8319bac2f7 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow_replace.pass.cpp
@@ -11,6 +11,9 @@
 
 // UNSUPPORTED: sanitizer-new-delete
 
+// TODO Investigate why UBSAN prevents nothrow new from calling our replacement.
+// XFAIL: ubsan
+
 #include <new>
 #include <cstddef>
 #include <cstdlib>
@@ -22,7 +25,9 @@ int new_called = 0;
 void* operator new(std::size_t s) throw(std::bad_alloc)
 {
     ++new_called;
-    return std::malloc(s);
+    void* ret = std::malloc(s);
+    if (!ret) std::abort(); // placate MSVC's unchecked malloc warning
+    return ret;
 }
 
 void  operator delete(void* p) throw()
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_replace.pass.cpp
index 0df3a93703d2..6056ed7bb0b3 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_replace.pass.cpp
@@ -22,7 +22,9 @@ int new_called = 0;
 void* operator new(std::size_t s) throw(std::bad_alloc)
 {
     ++new_called;
-    return std::malloc(s);
+    void* ret = std::malloc(s);
+    if (!ret) std::abort(); // placate MSVC's unchecked malloc warning
+    return ret;
 }
 
 void  operator delete(void* p) throw()
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete_calls_unsized_delete.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete_calls_unsized_delete.pass.cpp
index 5c4eba53d3e4..f656d1cd712a 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete_calls_unsized_delete.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete_calls_unsized_delete.pass.cpp
@@ -13,6 +13,10 @@
 
 // UNSUPPORTED: sanitizer-new-delete
 
+// TODO Investigate why UBSAN prevents new from calling our replacement.
+// XFAIL: ubsan
+
+
 #include <new>
 #include <cstddef>
 #include <cstdlib>
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete_fsizeddeallocation.sh.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete_fsizeddeallocation.sh.cpp
index da43d4969174..24d33e210f57 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete_fsizeddeallocation.sh.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete_fsizeddeallocation.sh.cpp
@@ -14,6 +14,9 @@
 
 // UNSUPPORTED: sanitizer-new-delete
 
+// TODO Investigate why UBSAN prevents new from calling our replacement.
+// XFAIL: ubsan
+
 // NOTE: Only clang-3.7 and GCC 5.1 and greater support -fsized-deallocation.
 // REQUIRES: fsized-deallocation
 
diff --git a/test/std/language.support/support.exception/except.nested/rethrow_if_nested.pass.cpp b/test/std/language.support/support.exception/except.nested/rethrow_if_nested.pass.cpp
index a8b6e15feab8..4ee95fdf3001 100644
--- a/test/std/language.support/support.exception/except.nested/rethrow_if_nested.pass.cpp
+++ b/test/std/language.support/support.exception/except.nested/rethrow_if_nested.pass.cpp
@@ -76,9 +76,9 @@ int main()
                     std::rethrow_if_nested(a);
                     assert(false);
                 }
-                catch (const B& b)
+                catch (const B& b2)
                 {
-                    assert(b == B(5));
+                    assert(b2 == B(5));
                 }
             }
         }
diff --git a/test/std/language.support/support.exception/except.nested/throw_with_nested.pass.cpp b/test/std/language.support/support.exception/except.nested/throw_with_nested.pass.cpp
index 98006bb1e3a0..c14cb69bdea3 100644
--- a/test/std/language.support/support.exception/except.nested/throw_with_nested.pass.cpp
+++ b/test/std/language.support/support.exception/except.nested/throw_with_nested.pass.cpp
@@ -18,6 +18,8 @@
 #include <cstdlib>
 #include <cassert>
 
+#include "test_macros.h"
+
 class A
 {
     int data_;
@@ -37,7 +39,7 @@ public:
     friend bool operator==(const B& x, const B& y) {return x.data_ == y.data_;}
 };
 
-#if __cplusplus > 201103L
+#if TEST_STD_VER > 11
 struct Final final {};
 #endif
 
@@ -105,14 +107,14 @@ int main()
             assert(i == 7);
         }
     }
-#if __cplusplus > 201103L
+#if TEST_STD_VER > 11
     {
         try
         {
             std::throw_with_nested(Final());
             assert(false);
         }
-        catch (const Final &f)
+        catch (const Final &)
         {
         }
     }
diff --git a/test/std/language.support/support.exception/propagation/current_exception.pass.cpp b/test/std/language.support/support.exception/propagation/current_exception.pass.cpp
index 09adf580bddf..7bf1df457dbe 100644
--- a/test/std/language.support/support.exception/propagation/current_exception.pass.cpp
+++ b/test/std/language.support/support.exception/propagation/current_exception.pass.cpp
@@ -74,7 +74,7 @@ int main()
             throw A();
             assert(false);
         }
-        catch (A& a)
+        catch (A&)
         {
             std::exception_ptr p = std::current_exception();
             assert(A::constructed == 1);
@@ -94,7 +94,7 @@ int main()
             throw A();
             assert(false);
         }
-        catch (A a)
+        catch (A)
         {
             std::exception_ptr p = std::current_exception();
             assert(A::constructed == 2);
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/const_data_members.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/const_data_members.pass.cpp
index bbead15da64f..50cfc4674251 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/const_data_members.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/const_data_members.pass.cpp
@@ -178,13 +178,13 @@ int main()
     TEST_NUMERIC_LIMITS(const float)
     TEST_NUMERIC_LIMITS(volatile float)
     TEST_NUMERIC_LIMITS(const volatile float)
-    
+
     // double
     TEST_NUMERIC_LIMITS(double)
     TEST_NUMERIC_LIMITS(const double)
     TEST_NUMERIC_LIMITS(volatile double)
     TEST_NUMERIC_LIMITS(const volatile double)
-    
+
     // long double
     TEST_NUMERIC_LIMITS(long double)
     TEST_NUMERIC_LIMITS(const long double)
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/denorm_min.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/denorm_min.pass.cpp
index a452d4e9949d..8deb28d3fd9c 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/denorm_min.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/denorm_min.pass.cpp
@@ -12,6 +12,7 @@
 // denorm_min()
 
 #include <limits>
+#include <cfloat>
 #include <cassert>
 
 template <class T>
@@ -47,7 +48,17 @@ int main()
     test<__int128_t>(0);
     test<__uint128_t>(0);
 #endif
+#if defined(__FLT_DENORM_MIN__) // guarded because these macros are extensions.
     test<float>(__FLT_DENORM_MIN__);
     test<double>(__DBL_DENORM_MIN__);
     test<long double>(__LDBL_DENORM_MIN__);
+#endif
+#if defined(FLT_TRUE_MIN) // not currently provided on linux.
+    test<float>(FLT_TRUE_MIN);
+    test<double>(DBL_TRUE_MIN);
+    test<long double>(LDBL_TRUE_MIN);
+#endif
+#if !defined(__FLT_DENORM_MIN__) && !defined(FLT_TRUE_MIN)
+#error Test has no expected values for floating point types
+#endif
 }
diff --git a/test/std/language.support/support.runtime/csetjmp.pass.cpp b/test/std/language.support/support.runtime/csetjmp.pass.cpp
index dc034ce099e2..f5060305608d 100644
--- a/test/std/language.support/support.runtime/csetjmp.pass.cpp
+++ b/test/std/language.support/support.runtime/csetjmp.pass.cpp
@@ -19,6 +19,7 @@
 int main()
 {
     std::jmp_buf jb;
+    ((void)jb); // Prevent unused warning
     static_assert((std::is_same<decltype(std::longjmp(jb, 0)), void>::value),
                   "std::is_same<decltype(std::longjmp(jb, 0)), void>::value");
 }
diff --git a/test/std/language.support/support.runtime/cstdarg.pass.cpp b/test/std/language.support/support.runtime/cstdarg.pass.cpp
index 9d6f610a943e..e7282b1c555e 100644
--- a/test/std/language.support/support.runtime/cstdarg.pass.cpp
+++ b/test/std/language.support/support.runtime/cstdarg.pass.cpp
@@ -11,11 +11,13 @@
 
 #include <cstdarg>
 
+#include "test_macros.h"
+
 #ifndef va_arg
 #error va_arg not defined
 #endif
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
 #  ifndef va_copy
 #    error va_copy is not defined when c++ >= 11
 #  endif
diff --git a/test/std/language.support/support.runtime/ctime.pass.cpp b/test/std/language.support/support.runtime/ctime.pass.cpp
index 03a0aa4d6966..34343b247f21 100644
--- a/test/std/language.support/support.runtime/ctime.pass.cpp
+++ b/test/std/language.support/support.runtime/ctime.pass.cpp
@@ -23,10 +23,13 @@
 int main()
 {
     std::clock_t c = 0;
-    ((void)c);
     std::size_t s = 0;
     std::time_t t = 0;
-    std::tm tm = {0};
+    std::tm tm = {};
+    ((void)c); // Prevent unused warning
+    ((void)s); // Prevent unused warning
+    ((void)t); // Prevent unused warning
+    ((void)tm); // Prevent unused warning
     static_assert((std::is_same<decltype(std::clock()), std::clock_t>::value), "");
     static_assert((std::is_same<decltype(std::difftime(t,t)), double>::value), "");
     static_assert((std::is_same<decltype(std::mktime(&tm)), std::time_t>::value), "");
@@ -39,5 +42,7 @@ int main()
 #endif
     char* c1 = 0;
     const char* c2 = 0;
+    ((void)c1); // Prevent unused warning
+    ((void)c2); // Prevent unused warning
     static_assert((std::is_same<decltype(std::strftime(c1,s,c2,&tm)), std::size_t>::value), "");
 }
diff --git a/test/std/language.support/support.types/nullptr_t.pass.cpp b/test/std/language.support/support.types/nullptr_t.pass.cpp
index 1cc2aa62032e..ca5170f649ed 100644
--- a/test/std/language.support/support.types/nullptr_t.pass.cpp
+++ b/test/std/language.support/support.types/nullptr_t.pass.cpp
@@ -57,10 +57,14 @@ void test_comparisons()
 #pragma clang diagnostic ignored "-Wnull-conversion"
 #endif
 void test_nullptr_conversions() {
+// GCC does not accept this due to CWG Defect #1423
+// http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1423
+#if defined(__clang__)
     {
         bool b = nullptr;
         assert(!b);
     }
+#endif
     {
         bool b(nullptr);
         assert(!b);
diff --git a/test/std/language.support/support.types/offsetof.pass.cpp b/test/std/language.support/support.types/offsetof.pass.cpp
index e36ac22974ff..d479f9ca44fa 100644
--- a/test/std/language.support/support.types/offsetof.pass.cpp
+++ b/test/std/language.support/support.types/offsetof.pass.cpp
@@ -7,8 +7,12 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 #include <cstddef>
 
+#include "test_macros.h"
+
 #ifndef offsetof
 #error offsetof not defined
 #endif
@@ -20,7 +24,5 @@ struct A
 
 int main()
 {
-#if (__has_feature(cxx_noexcept))
     static_assert(noexcept(offsetof(A, x)), "");
-#endif
 }
diff --git a/test/std/localization/c.locales/clocale.pass.cpp b/test/std/localization/c.locales/clocale.pass.cpp
index a90725bfa367..534213495cd9 100644
--- a/test/std/localization/c.locales/clocale.pass.cpp
+++ b/test/std/localization/c.locales/clocale.pass.cpp
@@ -47,6 +47,7 @@
 int main()
 {
     std::lconv lc;
+    ((void)lc); // Prevent unused warning
 #ifndef _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS
     static_assert((std::is_same<decltype(std::setlocale(0, "")), char*>::value), "");
 #endif
diff --git a/test/std/localization/locale.categories/category.collate/locale.collate.byname/compare.pass.cpp b/test/std/localization/locale.categories/category.collate/locale.collate.byname/compare.pass.cpp
index 09009ceaaae2..dfbdeaea954b 100644
--- a/test/std/localization/locale.categories/category.collate/locale.collate.byname/compare.pass.cpp
+++ b/test/std/localization/locale.categories/category.collate/locale.collate.byname/compare.pass.cpp
@@ -53,23 +53,6 @@ int main()
         }
     }
     {
-        std::locale l("");
-        {
-            const std::collate<char>& f = std::use_facet<std::collate<char> >(l);
-            std::string s2("aaaaaaA");
-            std::string s3("BaaaaaA");
-            assert(f.compare(s2.data(), s2.data() + s2.size(),
-                             s3.data(), s3.data() + s3.size()) == 1);
-        }
-        {
-            const std::collate<wchar_t>& f = std::use_facet<std::collate<wchar_t> >(l);
-            std::wstring s2(L"aaaaaaA");
-            std::wstring s3(L"BaaaaaA");
-            assert(f.compare(s2.data(), s2.data() + s2.size(),
-                             s3.data(), s3.data() + s3.size()) == 1);
-        }
-    }
-    {
         std::locale l("C");
         {
             const std::collate<char>& f = std::use_facet<std::collate<char> >(l);
diff --git a/test/std/localization/locale.categories/category.collate/locale.collate.byname/transform.pass.cpp b/test/std/localization/locale.categories/category.collate/locale.collate.byname/transform.pass.cpp
index d31705e5ad1b..b39e9ad74dc4 100644
--- a/test/std/localization/locale.categories/category.collate/locale.collate.byname/transform.pass.cpp
+++ b/test/std/localization/locale.categories/category.collate/locale.collate.byname/transform.pass.cpp
@@ -25,8 +25,6 @@
 
 int main()
 {
-    // Ensure that the default locale is not C.  If it is, the second tests will fail.
-    putenv(const_cast<char*>("LC_ALL=" LOCALE_en_US_UTF_8));
     {
         std::locale l(LOCALE_en_US_UTF_8);
         {
@@ -41,19 +39,6 @@ int main()
         }
     }
     {
-        std::locale l("");
-        {
-            std::string x("1234");
-            const std::collate<char>& f = std::use_facet<std::collate<char> >(l);
-            assert(f.transform(x.data(), x.data() + x.size()) != x);
-        }
-        {
-            std::wstring x(L"1234");
-            const std::collate<wchar_t>& f = std::use_facet<std::collate<wchar_t> >(l);
-            assert(f.transform(x.data(), x.data() + x.size()) != x);
-        }
-    }
-    {
         std::locale l("C");
         {
             std::string x("1234");
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.statics/classic_table.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.statics/classic_table.pass.cpp
index b5690e3c6b26..f7b0e5b71567 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.statics/classic_table.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.statics/classic_table.pass.cpp
@@ -30,7 +30,7 @@ int main()
     for ( size_t i = 0; i < 128; ++i ) // values above 128 are not consistent
     {
         mask set = 0;
-        
+
         if ( i  < 32  || i  > 126 ) set |= F::cntrl;
         if ( i >= 32  && i <= 126 ) set |= F::print;
 
@@ -51,9 +51,9 @@ int main()
         if ( i >=  58 && i <=  64 ) set |= F::punct;    // ':' .. '@'
         if ( i >=  91 && i <=  96 ) set |= F::punct;    // '[' .. '`'
         if ( i >= 123 && i <= 126 ) set |= F::punct;    // '{' .. '~'    }
-        
+
         assert(( p[i] &  set) == set);            // all the right bits set
         assert(((p[i] & ~set) & defined) == 0);   // no extra ones
     }
-    
+
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/types.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/types.pass.cpp
index fdfab5769043..0e9909720c0b 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/types.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/types.pass.cpp
@@ -45,19 +45,6 @@ int main()
         }
     }
     {
-        std::locale l("");
-        {
-            assert(std::has_facet<std::ctype_byname<char> >(l));
-            assert(&std::use_facet<std::ctype<char> >(l)
-                == &std::use_facet<std::ctype_byname<char> >(l));
-        }
-        {
-            assert(std::has_facet<std::ctype_byname<wchar_t> >(l));
-            assert(&std::use_facet<std::ctype<wchar_t> >(l)
-                == &std::use_facet<std::ctype_byname<wchar_t> >(l));
-        }
-    }
-    {
         std::locale l("C");
         {
             assert(std::has_facet<std::ctype_byname<char> >(l));
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/money_base.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/money_base.pass.cpp
index beabe0cae660..a0c17dcae7d0 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/money_base.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/money_base.pass.cpp
@@ -21,13 +21,13 @@
 
 int main()
 {
-    std::money_base mb;
-    assert(mb.none == 0);
-    assert(mb.space == 1);
-    assert(mb.symbol == 2);
-    assert(mb.sign == 3);
-    assert(mb.value == 4);
-    assert(sizeof(std::money_base::pattern) == 4);
+    std::money_base mb; ((void)mb);
+    static_assert(std::money_base::none == 0, "");
+    static_assert(std::money_base::space == 1, "");
+    static_assert(std::money_base::symbol == 2, "");
+    static_assert(std::money_base::sign == 3, "");
+    static_assert(std::money_base::value == 4, "");
+    static_assert(sizeof(std::money_base::pattern) == 4, "");
     std::money_base::pattern p;
     p.field[0] = std::money_base::none;
 }
diff --git a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_double.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_double.pass.cpp
index a54b37314e87..596f8f80f04e 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_double.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_double.pass.cpp
@@ -13,6 +13,9 @@
 
 // iter_type put(iter_type s, ios_base& iob, char_type fill, double v) const;
 
+// TODO(EricWF): This test takes 40+ minutes to build with Clang 3.8 under ASAN or MSAN.
+// UNSUPPORTED: asan, msan
+
 #include <locale>
 #include <ios>
 #include <cassert>
diff --git a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_double.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_double.pass.cpp
index 935961257ef2..cf9339341abb 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_double.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_double.pass.cpp
@@ -13,6 +13,9 @@
 
 // iter_type put(iter_type s, ios_base& iob, char_type fill, long double v) const;
 
+// TODO(EricWF): This test takes 40+ minutes to build with Clang 3.8 under ASAN or MSAN.
+// UNSUPPORTED: asan, msan
+
 // TODO GLIBC uses a different string for positive and negative NAN numbers.
 // XFAIL: linux-gnu
 
@@ -24412,14 +24415,14 @@ void test11()
 
 void test12()
 {
-    char str[200];
     output_iterator<char*> iter;
     std::locale lc = std::locale::classic();
     std::locale lg(lc, new my_numpunct);
 #ifdef __APPLE__
 // This test is failing on FreeBSD, possibly due to different representations
-// of the floating point numbers.  
+// of the floating point numbers.
     const my_facet f(1);
+    char str[200];
     {
         long double v = 1234567890.125;
         std::ios ios(0);
@@ -26218,7 +26221,6 @@ int main()
     test10();
     test11();
     test12();
-    char str[200];
     output_iterator<char*> iter;
     std::locale lc = std::locale::classic();
     std::locale lg(lc, new my_numpunct);
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_double.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_double.pass.cpp
index f5c7c1277c31..6d7f506bb2d4 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_double.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_double.pass.cpp
@@ -207,6 +207,30 @@ int main()
         assert(err == ios.goodbit);
         assert(v == 2);
     }
+    {
+        v = -1;
+        const char str[] = "1.79779e+309"; // unrepresentable
+        std::ios_base::iostate err = ios.goodbit;
+        input_iterator<const char*> iter =
+            f.get(input_iterator<const char*>(str),
+                  input_iterator<const char*>(str+sizeof(str)),
+                  ios, err, v);
+        assert(iter.base() == str+sizeof(str)-1);
+        assert(err == ios.failbit);
+        assert(v == HUGE_VAL);
+    }
+    {
+        v = -1;
+        const char str[] = "-1.79779e+308"; // unrepresentable
+        std::ios_base::iostate err = ios.goodbit;
+        input_iterator<const char*> iter =
+            f.get(input_iterator<const char*>(str),
+                  input_iterator<const char*>(str+sizeof(str)),
+                  ios, err, v);
+        assert(iter.base() == str+sizeof(str)-1);
+        assert(err == ios.failbit);
+        assert(v == -HUGE_VAL);
+    }
     ios.imbue(std::locale(std::locale(), new my_numpunct));
     {
         v = -1;
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_float.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_float.pass.cpp
index 9138894784ed..d01f63d5920d 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_float.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_float.pass.cpp
@@ -32,6 +32,7 @@ public:
         : F(refs) {}
 };
 
+
 int main()
 {
     const my_facet f(1);
@@ -168,4 +169,29 @@ int main()
         assert(err == ios.goodbit);
         assert(std::isnan(v));
     }
+    {
+        v = -1;
+        const char str[] = "3.40283e+39"; // unrepresentable
+        std::ios_base::iostate err = ios.goodbit;
+        input_iterator<const char*> iter =
+            f.get(input_iterator<const char*>(str),
+                  input_iterator<const char*>(str+sizeof(str)),
+                  ios, err, v);
+        assert(iter.base() == str+sizeof(str)-1);
+        assert(err == ios.failbit);
+        assert(v == HUGE_VALF);
+    }
+    {
+        v = -1;
+        const char str[] = "-3.40283e+38"; // unrepresentable
+        std::ios_base::iostate err = ios.goodbit;
+        input_iterator<const char*> iter =
+            f.get(input_iterator<const char*>(str),
+                  input_iterator<const char*>(str+sizeof(str)),
+                  ios, err, v);
+        assert(iter.base() == str+sizeof(str)-1);
+        assert(err == ios.failbit);
+        assert(v == -HUGE_VALF);
+
+    }
 }
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_double.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_double.pass.cpp
index 8e89ebc470cf..b79650b0199b 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_double.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_double.pass.cpp
@@ -32,6 +32,7 @@ public:
         : F(refs) {}
 };
 
+
 int main()
 {
     const my_facet f(1);
@@ -228,4 +229,28 @@ int main()
         assert(err != ios.failbit);
         assert(v == 304888344611713860501504000000.0L);
     }
+    {
+        v = -1;
+        const char str[] = "1.19973e+4933"; // unrepresentable
+        std::ios_base::iostate err = ios.goodbit;
+        input_iterator<const char*> iter =
+            f.get(input_iterator<const char*>(str),
+                  input_iterator<const char*>(str+sizeof(str)),
+                  ios, err, v);
+        assert(iter.base() == str+sizeof(str)-1);
+        assert(err == ios.failbit);
+        assert(v == HUGE_VALL);
+    }
+    {
+        v = -1;
+        const char str[] = "-1.18974e+4932"; // unrepresentable
+        std::ios_base::iostate err = ios.goodbit;
+        input_iterator<const char*> iter =
+            f.get(input_iterator<const char*>(str),
+                  input_iterator<const char*>(str+sizeof(str)),
+                  ios, err, v);
+        assert(iter.base() == str+sizeof(str)-1);
+        assert(err == ios.failbit);
+        assert(v == -HUGE_VALL);
+    }
 }
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_min_max.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_min_max.pass.cpp
index e474eca2f5b2..6ba5a89e61e4 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_min_max.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_min_max.pass.cpp
@@ -25,14 +25,14 @@ void check_limits()
     assert(miniss << minv);
     assert(maxiss << maxv);
     std::string mins = miniss.str();
-    std::string maxs = maxiss.str(); 
+    std::string maxs = maxiss.str();
 
     istringstream maxoss(maxs), minoss(mins);
 
     T new_minv, new_maxv;
     assert(maxoss >> new_maxv);
     assert(minoss >> new_minv);
- 
+
     assert(new_minv == minv);
     assert(new_maxv == maxv);
 
@@ -40,11 +40,11 @@ void check_limits()
         mins = "-1";
     else
         mins[mins.size() - 1]++;
-    
+
     maxs[maxs.size() - 1]++;
 
     istringstream maxoss2(maxs), minoss2(mins);
-    
+
     assert(! (maxoss2 >> new_maxv));
     assert(! (minoss2 >> new_minv));
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname.pass.cpp
index 7ad431652a89..931ab5d40964 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname.pass.cpp
@@ -9,15 +9,8 @@
 
 // REQUIRES: locale.en_US.UTF-8
 // REQUIRES: locale.fr_FR.UTF-8
-// REQUIRES: locale.ru_RU.UTF-8
 // REQUIRES: locale.zh_CN.UTF-8
 
-// NOTE: debian and opensuse use old locale data for ru_RU.UTF-8 abbreviated
-// months. This locale data was changed in glibc 2.14.
-// Debian uses glibc 2.13 as of 20/11/2014
-// OpenSuse uses glibc 2.19 with old locale data as of 20/11/2014
-// XFAIL: debian, opensuse
-
 // <locale>
 
 // class time_get_byname<charT, InputIterator>
@@ -70,16 +63,6 @@ int main()
         assert(err == std::ios_base::eofbit);
     }
     {
-        const my_facet f(LOCALE_ru_RU_UTF_8, 1);
-        const char in[] = "\xD0\xB8\xD1\x8E\xD0\xBD\xD1\x8F";
-        err = std::ios_base::goodbit;
-        t = std::tm();
-        I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
-        assert(t.tm_mon == 5);
-        assert(err == std::ios_base::eofbit);
-    }
-    {
         const my_facet f(LOCALE_zh_CN_UTF_8, 1);
         const char in[] = "\xE5\x85\xAD\xE6\x9C\x88";
         err = std::ios_base::goodbit;
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname_wide.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname_wide.pass.cpp
index 631a6de03d82..551f298b0419 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname_wide.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname_wide.pass.cpp
@@ -9,15 +9,8 @@
 
 // REQUIRES: locale.en_US.UTF-8
 // REQUIRES: locale.fr_FR.UTF-8
-// REQUIRES: locale.ru_RU.UTF-8
 // REQUIRES: locale.zh_CN.UTF-8
 
-// NOTE: debian and opensuse use bad locale data for ru_RU.UTF-8 abbreviated
-// months. This locale data was fixed in glibc 2.14.
-// Debian uses glibc 2.13 as of 20/11/2014
-// OpenSuse uses glibc 2.19 with old locale data as of 20/11/2014
-// XFAIL: debian, opensuse
-
 // <locale>
 
 // class time_get_byname<charT, InputIterator>
@@ -79,16 +72,6 @@ int main()
         assert(err == std::ios_base::eofbit);
     }
     {
-        const my_facet f(LOCALE_ru_RU_UTF_8, 1);
-        const wchar_t in[] = L"\x438\x44E\x43D\x44F";
-        err = std::ios_base::goodbit;
-        t = std::tm();
-        I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
-        assert(t.tm_mon == 5);
-        assert(err == std::ios_base::eofbit);
-    }
-    {
         const my_facet f(LOCALE_zh_CN_UTF_8, 1);
         const wchar_t in[] = L"\x516D\x6708";
         err = std::ios_base::goodbit;
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one_wide.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one_wide.pass.cpp
index ae8bce22445a..4a2b3819b507 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one_wide.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one_wide.pass.cpp
@@ -75,7 +75,7 @@ int main()
     }
     {
         const my_facet f(LOCALE_fr_FR_UTF_8, 1);
-        const wchar_t in[] = L"Sam 31 d""\xE9""c 23:55:59 2061";
+        const wchar_t in[] = L"Sam 31 d" L"\xE9" L"c 23:55:59 2061";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t, 'c');
@@ -105,11 +105,11 @@ int main()
     {
         const my_facet f("ru_RU", 1);
         const wchar_t in[] = L"\x441\x443\x431\x431\x43E\x442\x430"
-                          ", 31 "
-                          "\x434\x435\x43A\x430\x431\x440\x44F"
-                          " 2061 "
-                          "\x433"
-                          ". 23:55:59";
+                          L", 31 "
+                          L"\x434\x435\x43A\x430\x431\x440\x44F"
+                          L" 2061 "
+                          L"\x433"
+                          L". 23:55:59";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t, 'c');
@@ -140,7 +140,7 @@ int main()
     {
         const my_facet f("zh_CN", 1);
         const wchar_t in[] = L"\x516D"
-                          " 12/31 23:55:59 2061";
+                          L" 12/31 23:55:59 2061";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t, 'c');
@@ -157,7 +157,7 @@ int main()
 #endif
     {
         const my_facet f(LOCALE_zh_CN_UTF_8, 1);
-        const wchar_t in[] = L"23""\x65F6""55""\x5206""59""\x79D2";
+        const wchar_t in[] = L"23" L"\x65F6" L"55" L"\x5206" L"59" L"\x79D2";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t, 'X');
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_copy.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_copy.pass.cpp
new file mode 100644
index 000000000000..72e79dfb1e7f
--- /dev/null
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_copy.pass.cpp
@@ -0,0 +1,31 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// These constructors are still unavailable in C++03, but this test depends
+// on access control SFINAE and fails without it.
+// UNSUPPORTED: c++98, c++03
+
+// <locale>
+
+// wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc>
+
+// wstring_convert(wstring_convert const&) = delete;
+// wstring_convert& operator=(wstring_convert const&) = delete;
+
+#include <locale>
+#include <codecvt>
+#include <cassert>
+
+int main()
+{
+    typedef std::codecvt_utf8<wchar_t> Codecvt;
+    typedef std::wstring_convert<Codecvt> Myconv;
+    static_assert(!std::is_copy_constructible<Myconv>::value, "");
+    static_assert(!std::is_copy_assignable<Myconv>::value, "");
+}
diff --git a/test/std/localization/locales/locale/locale.cons/assign.pass.cpp b/test/std/localization/locales/locale/locale.cons/assign.pass.cpp
index 80afe1e46aad..8b31a8f97498 100644
--- a/test/std/localization/locales/locale/locale.cons/assign.pass.cpp
+++ b/test/std/localization/locales/locale/locale.cons/assign.pass.cpp
@@ -8,7 +8,6 @@
 //===----------------------------------------------------------------------===//
 
 // REQUIRES: locale.ru_RU.UTF-8
-// UNSUPPORTED: sanitizer-new-delete
 
 // <locale>
 
@@ -18,21 +17,10 @@
 #include <cassert>
 #include <new>
 
-#include "platform_support.h" // locale name macros
-
-int new_called = 0;
+#include "count_new.hpp"
 
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    ++new_called;
-    return std::malloc(s);
-}
+#include "platform_support.h" // locale name macros
 
-void  operator delete(void* p) throw()
-{
-    --new_called;
-    std::free(p);
-}
 
 void check(const std::locale& loc)
 {
@@ -79,5 +67,5 @@ int main()
         check(loc);
         check(loc2);
     }
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
 }
diff --git a/test/std/localization/locales/locale/locale.cons/char_pointer.pass.cpp b/test/std/localization/locales/locale/locale.cons/char_pointer.pass.cpp
index b808a7650c47..c7021df8f577 100644
--- a/test/std/localization/locales/locale/locale.cons/char_pointer.pass.cpp
+++ b/test/std/localization/locales/locale/locale.cons/char_pointer.pass.cpp
@@ -10,7 +10,6 @@
 // XFAIL: libcpp-no-exceptions
 // REQUIRES: locale.ru_RU.UTF-8
 // REQUIRES: locale.zh_CN.UTF-8
-// UNSUPPORTED: sanitizer-new-delete
 
 // <locale>
 
@@ -20,21 +19,9 @@
 #include <new>
 #include <cassert>
 
+#include "count_new.hpp"
 #include "platform_support.h" // locale name macros
 
-int new_called = 0;
-
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    ++new_called;
-    return std::malloc(s);
-}
-
-void  operator delete(void* p) throw()
-{
-    --new_called;
-    std::free(p);
-}
 
 void check(const std::locale& loc)
 {
@@ -101,5 +88,5 @@ int main()
         }
         std::locale ok("");
     }
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
 }
diff --git a/test/std/localization/locales/locale/locale.cons/copy.pass.cpp b/test/std/localization/locales/locale/locale.cons/copy.pass.cpp
index 0760cc46cdd8..9e446e440851 100644
--- a/test/std/localization/locales/locale/locale.cons/copy.pass.cpp
+++ b/test/std/localization/locales/locale/locale.cons/copy.pass.cpp
@@ -8,7 +8,6 @@
 //===----------------------------------------------------------------------===//
 
 // REQUIRES: locale.fr_FR.UTF-8
-// UNSUPPORTED: sanitizer-new-delete
 
 // <locale>
 
@@ -18,22 +17,9 @@
 #include <cassert>
 #include <new>
 
+#include "count_new.hpp"
 #include "platform_support.h" // locale name macros
 
-int new_called = 0;
-
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    ++new_called;
-    return std::malloc(s);
-}
-
-void  operator delete(void* p) throw()
-{
-    --new_called;
-    std::free(p);
-}
-
 void check(const std::locale& loc)
 {
     assert(std::has_facet<std::collate<char> >(loc));
@@ -78,5 +64,5 @@ int main()
         check(loc);
         check(loc2);
     }
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
 }
diff --git a/test/std/localization/locales/locale/locale.cons/locale_char_pointer_cat.pass.cpp b/test/std/localization/locales/locale/locale.cons/locale_char_pointer_cat.pass.cpp
index 2a9e20fcf98d..eb381f9a580d 100644
--- a/test/std/localization/locales/locale/locale.cons/locale_char_pointer_cat.pass.cpp
+++ b/test/std/localization/locales/locale/locale.cons/locale_char_pointer_cat.pass.cpp
@@ -9,7 +9,6 @@
 
 // REQUIRES: locale.en_US.UTF-8
 // REQUIRES: locale.ru_RU.UTF-8
-// UNSUPPORTED: sanitizer-new-delete
 
 // <locale>
 
@@ -19,22 +18,9 @@
 #include <new>
 #include <cassert>
 
+#include "count_new.hpp"
 #include "platform_support.h" // locale name macros
 
-int new_called = 0;
-
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    ++new_called;
-    return std::malloc(s);
-}
-
-void  operator delete(void* p) throw()
-{
-    --new_called;
-    std::free(p);
-}
-
 void check(const std::locale& loc)
 {
     assert(std::has_facet<std::collate<char> >(loc));
@@ -78,5 +64,5 @@ int main()
         std::locale loc2(loc, LOCALE_en_US_UTF_8, std::locale::monetary);
         check(loc2);
     }
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
 }
diff --git a/test/std/localization/locales/locale/locale.cons/locale_facetptr.pass.cpp b/test/std/localization/locales/locale/locale.cons/locale_facetptr.pass.cpp
index fb6e39e5742f..1144931e3d2c 100644
--- a/test/std/localization/locales/locale/locale.cons/locale_facetptr.pass.cpp
+++ b/test/std/localization/locales/locale/locale.cons/locale_facetptr.pass.cpp
@@ -8,7 +8,6 @@
 //===----------------------------------------------------------------------===//
 
 // REQUIRES: locale.ru_RU.UTF-8
-// UNSUPPORTED: sanitizer-new-delete
 
 // <locale>
 
@@ -18,21 +17,9 @@
 #include <new>
 #include <cassert>
 
+#include "count_new.hpp"
 #include "platform_support.h" // locale name macros
 
-int new_called = 0;
-
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    ++new_called;
-    return std::malloc(s);
-}
-
-void  operator delete(void* p) throw()
-{
-    --new_called;
-    std::free(p);
-}
 
 void check(const std::locale& loc)
 {
@@ -81,7 +68,6 @@ std::locale::id my_facet::id;
 
 int main()
 {
-{
     {
         std::locale loc(LOCALE_ru_RU_UTF_8);
         check(loc);
@@ -91,9 +77,7 @@ int main()
         const my_facet& f = std::use_facet<my_facet>(loc2);
         assert(f.test() == 5);
     }
-    assert(new_called == 0);
-}
-{
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     {
         std::locale loc;
         check(loc);
@@ -101,6 +85,5 @@ int main()
         check(loc2);
         assert(loc == loc2);
     }
-    assert(new_called == 0);
-}
+    assert(globalMemCounter.checkOutstandingNewEq(0));
 }
diff --git a/test/std/localization/locales/locale/locale.cons/locale_locale_cat.pass.cpp b/test/std/localization/locales/locale/locale.cons/locale_locale_cat.pass.cpp
index fa87eb20e9af..f1afff66580e 100644
--- a/test/std/localization/locales/locale/locale.cons/locale_locale_cat.pass.cpp
+++ b/test/std/localization/locales/locale/locale.cons/locale_locale_cat.pass.cpp
@@ -9,7 +9,6 @@
 
 // REQUIRES: locale.en_US.UTF-8
 // REQUIRES: locale.ru_RU.UTF-8
-// UNSUPPORTED: sanitizer-new-delete
 
 // <locale>
 
@@ -19,22 +18,9 @@
 #include <new>
 #include <cassert>
 
+#include "count_new.hpp"
 #include "platform_support.h" // locale name macros
 
-int new_called = 0;
-
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    ++new_called;
-    return std::malloc(s);
-}
-
-void  operator delete(void* p) throw()
-{
-    --new_called;
-    std::free(p);
-}
-
 void check(const std::locale& loc)
 {
     assert(std::has_facet<std::collate<char> >(loc));
@@ -78,5 +64,5 @@ int main()
         std::locale loc2(loc, std::locale(LOCALE_en_US_UTF_8), std::locale::monetary);
         check(loc2);
     }
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
 }
diff --git a/test/std/localization/locales/locale/locale.cons/locale_string_cat.pass.cpp b/test/std/localization/locales/locale/locale.cons/locale_string_cat.pass.cpp
index 59fbc59b90da..eb63cd03b663 100644
--- a/test/std/localization/locales/locale/locale.cons/locale_string_cat.pass.cpp
+++ b/test/std/localization/locales/locale/locale.cons/locale_string_cat.pass.cpp
@@ -6,10 +6,9 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
- 
+
 // REQUIRES: locale.en_US.UTF-8
 // REQUIRES: locale.ru_RU.UTF-8
-// UNSUPPORTED: sanitizer-new-delete
 
 // <locale>
 
@@ -19,21 +18,9 @@
 #include <new>
 #include <cassert>
 
+#include "count_new.hpp"
 #include "platform_support.h" // locale name macros
 
-int new_called = 0;
-
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    ++new_called;
-    return std::malloc(s);
-}
-
-void  operator delete(void* p) throw()
-{
-    --new_called;
-    std::free(p);
-}
 
 void check(const std::locale& loc)
 {
@@ -78,5 +65,5 @@ int main()
         std::locale loc2(loc, std::string(LOCALE_en_US_UTF_8), std::locale::monetary);
         check(loc2);
     }
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
 }
diff --git a/test/std/localization/locales/locale/locale.cons/string.pass.cpp b/test/std/localization/locales/locale/locale.cons/string.pass.cpp
index c9f944196e73..6fc0808b2728 100644
--- a/test/std/localization/locales/locale/locale.cons/string.pass.cpp
+++ b/test/std/localization/locales/locale/locale.cons/string.pass.cpp
@@ -9,7 +9,6 @@
 
 // REQUIRES: locale.ru_RU.UTF-8
 // REQUIRES: locale.zh_CN.UTF-8
-// UNSUPPORTED: sanitizer-new-delete
 
 // <locale>
 
@@ -19,22 +18,9 @@
 #include <new>
 #include <cassert>
 
+#include "count_new.hpp"
 #include "platform_support.h" // locale name macros
 
-int new_called = 0;
-
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    ++new_called;
-    return std::malloc(s);
-}
-
-void  operator delete(void* p) throw()
-{
-    --new_called;
-    std::free(p);
-}
-
 void check(const std::locale& loc)
 {
     assert(std::has_facet<std::collate<char> >(loc));
@@ -83,5 +69,5 @@ int main()
         assert(!(loc == loc3));
         assert(loc != loc3);
     }
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
 }
diff --git a/test/std/localization/locales/locale/locale.types/locale.facet/tested_elsewhere.pass.cpp b/test/std/localization/locales/locale/locale.types/locale.facet/tested_elsewhere.pass.cpp
new file mode 100644
index 000000000000..b58f5c55b643
--- /dev/null
+++ b/test/std/localization/locales/locale/locale.types/locale.facet/tested_elsewhere.pass.cpp
@@ -0,0 +1,12 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+int main()
+{
+}
diff --git a/test/std/localization/locales/locale/locale.types/locale.id/tested_elsewhere.pass.cpp b/test/std/localization/locales/locale/locale.types/locale.id/tested_elsewhere.pass.cpp
new file mode 100644
index 000000000000..b58f5c55b643
--- /dev/null
+++ b/test/std/localization/locales/locale/locale.types/locale.id/tested_elsewhere.pass.cpp
@@ -0,0 +1,12 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+int main()
+{
+}
diff --git a/test/std/numerics/c.math/cmath.pass.cpp b/test/std/numerics/c.math/cmath.pass.cpp
index 0b0d86288737..7161bd37e3e2 100644
--- a/test/std/numerics/c.math/cmath.pass.cpp
+++ b/test/std/numerics/c.math/cmath.pass.cpp
@@ -9,13 +9,11 @@
 
 // <cmath>
 
-// NOTE: isinf and isnan are tested separately because they are expected to fail
-// on linux. We don't want their expected failure to hide other failures in this file.
-
 #include <cmath>
 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
 #include "hexfloat.h"
 
 // convertible to int/float/double/etc
@@ -79,6 +77,7 @@ Ambiguous fma(Ambiguous, Ambiguous, Ambiguous){ return Ambiguous(); }
 Ambiguous fmax(Ambiguous, Ambiguous){ return Ambiguous(); }
 Ambiguous fmin(Ambiguous, Ambiguous){ return Ambiguous(); }
 Ambiguous hypot(Ambiguous, Ambiguous){ return Ambiguous(); }
+Ambiguous hypot(Ambiguous, Ambiguous, Ambiguous){ return Ambiguous(); }
 Ambiguous ilogb(Ambiguous){ return Ambiguous(); }
 Ambiguous lgamma(Ambiguous){ return Ambiguous(); }
 Ambiguous llrint(Ambiguous){ return Ambiguous(); }
@@ -631,6 +630,29 @@ void test_isgreaterequal()
     assert(std::isgreaterequal(-1.0, 0.F) == false);
 }
 
+void test_isinf()
+{
+#ifdef isinf
+#error isinf defined
+#endif
+    static_assert((std::is_same<decltype(std::isinf((float)0)), bool>::value), "");
+
+    typedef decltype(std::isinf((double)0)) DoubleRetType;
+#ifndef __linux__
+    static_assert((std::is_same<DoubleRetType, bool>::value), "");
+#else
+    // GLIBC < 2.26 defines 'isinf(double)' with a return type of 'int' in
+    // all C++ dialects. The test should tolerate this.
+    // See: https://sourceware.org/bugzilla/show_bug.cgi?id=19439
+    static_assert((std::is_same<DoubleRetType, bool>::value
+                || std::is_same<DoubleRetType, int>::value), "");
+#endif
+
+    static_assert((std::is_same<decltype(std::isinf(0)), bool>::value), "");
+    static_assert((std::is_same<decltype(std::isinf((long double)0)), bool>::value), "");
+    assert(std::isinf(-1.0) == false);
+}
+
 void test_isless()
 {
 #ifdef isless
@@ -688,6 +710,29 @@ void test_islessgreater()
     assert(std::islessgreater(-1.0, 0.F) == true);
 }
 
+void test_isnan()
+{
+#ifdef isnan
+#error isnan defined
+#endif
+    static_assert((std::is_same<decltype(std::isnan((float)0)), bool>::value), "");
+
+    typedef decltype(std::isnan((double)0)) DoubleRetType;
+#ifndef __linux__
+    static_assert((std::is_same<DoubleRetType, bool>::value), "");
+#else
+    // GLIBC < 2.26 defines 'isnan(double)' with a return type of 'int' in
+    // all C++ dialects. The test should tolerate this.
+    // See: https://sourceware.org/bugzilla/show_bug.cgi?id=19439
+    static_assert((std::is_same<DoubleRetType, bool>::value
+                || std::is_same<DoubleRetType, int>::value), "");
+#endif
+
+    static_assert((std::is_same<decltype(std::isnan(0)), bool>::value), "");
+    static_assert((std::is_same<decltype(std::isnan((long double)0)), bool>::value), "");
+    assert(std::isnan(-1.0) == false);
+}
+
 void test_isunordered()
 {
 #ifdef isunordered
@@ -1010,6 +1055,28 @@ void test_hypot()
     static_assert((std::is_same<decltype(std::hypot((int)0, (int)0)), double>::value), "");
     static_assert((std::is_same<decltype(hypot(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(std::hypot(3,4) == 5);
+
+#if TEST_STD_VER > 14
+    static_assert((std::is_same<decltype(std::hypot((float)0, (float)0, (float)0)), float>::value), "");
+    static_assert((std::is_same<decltype(std::hypot((float)0, (bool)0, (float)0)), double>::value), "");
+    static_assert((std::is_same<decltype(std::hypot((float)0, (unsigned short)0, (double)0)), double>::value), "");
+    static_assert((std::is_same<decltype(std::hypot((float)0, (int)0, (long double)0)), long double>::value), "");
+    static_assert((std::is_same<decltype(std::hypot((float)0, (unsigned int)0)), double>::value), "");
+    static_assert((std::is_same<decltype(std::hypot((float)0, (double)0, (long)0)), double>::value), "");
+    static_assert((std::is_same<decltype(std::hypot((float)0, (long double)0, (unsigned long)0)), long double>::value), "");
+    static_assert((std::is_same<decltype(std::hypot((float)0, (int)0, (long long)0)), double>::value), "");
+    static_assert((std::is_same<decltype(std::hypot((float)0, (int)0, (unsigned long long)0)), double>::value), "");
+    static_assert((std::is_same<decltype(std::hypot((float)0, (double)0, (double)0)), double>::value), "");
+    static_assert((std::is_same<decltype(std::hypot((float)0, (long double)0, (long double)0)), long double>::value), "");
+    static_assert((std::is_same<decltype(std::hypot((float)0, (float)0, (double)0)), double>::value), "");
+    static_assert((std::is_same<decltype(std::hypot((float)0, (float)0, (long double)0)), long double>::value), "");
+    static_assert((std::is_same<decltype(std::hypot((float)0, (double)0, (long double)0)), long double>::value), "");
+    static_assert((std::is_same<decltype(std::hypot((int)0, (int)0, (int)0)), double>::value), "");
+    static_assert((std::is_same<decltype(hypot(Ambiguous(), Ambiguous(), Ambiguous())), Ambiguous>::value), "");
+
+    assert(std::hypot(2,3,6) == 7);
+    assert(std::hypot(1,4,8) == 9);
+#endif
 }
 
 void test_ilogb()
@@ -1443,9 +1510,11 @@ int main()
     test_isnormal();
     test_isgreater();
     test_isgreaterequal();
+    test_isinf();
     test_isless();
     test_islessequal();
     test_islessgreater();
+    test_isnan();
     test_isunordered();
     test_acosh();
     test_asinh();
diff --git a/test/std/numerics/c.math/cmath_isinf.pass.cpp b/test/std/numerics/c.math/cmath_isinf.pass.cpp
deleted file mode 100644
index 6cde04d9bc86..000000000000
--- a/test/std/numerics/c.math/cmath_isinf.pass.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// <cmath>
-
-// isinf
-
-// XFAIL: linux
-
-#include <cmath>
-#include <type_traits>
-#include <cassert>
-
-int main()
-{
-#ifdef isinf
-#error isinf defined
-#endif
-    static_assert((std::is_same<decltype(std::isinf((float)0)), bool>::value), "");
-    static_assert((std::is_same<decltype(std::isinf((double)0)), bool>::value), "");
-    static_assert((std::is_same<decltype(std::isinf(0)), bool>::value), "");
-    static_assert((std::is_same<decltype(std::isinf((long double)0)), bool>::value), "");
-    assert(std::isinf(-1.0) == false);
-}
\ No newline at end of file
diff --git a/test/std/numerics/c.math/cmath_isnan.pass.cpp b/test/std/numerics/c.math/cmath_isnan.pass.cpp
deleted file mode 100644
index 7b33b9647052..000000000000
--- a/test/std/numerics/c.math/cmath_isnan.pass.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// <cmath>
-
-// isnan
-
-// XFAIL: linux
-
-#include <cmath>
-#include <type_traits>
-#include <cassert>
-
-int main()
-{
-#ifdef isnan
-#error isnan defined
-#endif
-    static_assert((std::is_same<decltype(std::isnan((float)0)), bool>::value), "");
-    static_assert((std::is_same<decltype(std::isnan((double)0)), bool>::value), "");
-    static_assert((std::is_same<decltype(std::isnan(0)), bool>::value), "");
-    static_assert((std::is_same<decltype(std::isnan((long double)0)), bool>::value), "");
-    assert(std::isnan(-1.0) == false);
-}
diff --git a/test/std/numerics/cfenv/cfenv.syn/cfenv.pass.cpp b/test/std/numerics/cfenv/cfenv.syn/cfenv.pass.cpp
index fcf075a36e1a..f2bf6433ceb4 100644
--- a/test/std/numerics/cfenv/cfenv.syn/cfenv.pass.cpp
+++ b/test/std/numerics/cfenv/cfenv.syn/cfenv.pass.cpp
@@ -62,6 +62,8 @@ int main()
 {
     std::fenv_t fenv;
     std::fexcept_t fex;
+    ((void)fenv); // Prevent unused warning
+    ((void)fex); // Prevent unused warning
     static_assert((std::is_same<decltype(std::feclearexcept(0)), int>::value), "");
     static_assert((std::is_same<decltype(std::fegetexceptflag(&fex, 0)), int>::value), "");
     static_assert((std::is_same<decltype(std::feraiseexcept(0)), int>::value), "");
diff --git a/test/std/numerics/complex.number/cases.h b/test/std/numerics/complex.number/cases.h
index cd6bd165a9d1..a2f85d11ca4d 100644
--- a/test/std/numerics/complex.number/cases.h
+++ b/test/std/numerics/complex.number/cases.h
@@ -17,7 +17,7 @@
 #include <complex>
 #include <cassert>
 
-std::complex<double> x[] =
+const std::complex<double> testcases[] =
 {
     std::complex<double>( 1.e-6,  1.e-6),
     std::complex<double>(-1.e-6,  1.e-6),
diff --git a/test/std/numerics/complex.number/cmplx.over/imag.pass.cpp b/test/std/numerics/complex.number/cmplx.over/imag.pass.cpp
index 30c95c3c88d9..7decea877fbd 100644
--- a/test/std/numerics/complex.number/cmplx.over/imag.pass.cpp
+++ b/test/std/numerics/complex.number/cmplx.over/imag.pass.cpp
@@ -30,7 +30,7 @@ test(typename std::enable_if<std::is_integral<T>::value>::type* = 0)
     static_assert(std::imag(val) == 0, "");
     constexpr std::complex<T> t{val, val};
     static_assert(t.imag() == x, "" );
-#endif    
+#endif
 }
 
 template <class T, int x>
@@ -44,7 +44,7 @@ test(typename std::enable_if<!std::is_integral<T>::value>::type* = 0)
     static_assert(std::imag(val) == 0, "");
     constexpr std::complex<T> t{val, val};
     static_assert(t.imag() == x, "" );
-#endif    
+#endif
 }
 
 template <class T>
diff --git a/test/std/numerics/complex.number/cmplx.over/real.pass.cpp b/test/std/numerics/complex.number/cmplx.over/real.pass.cpp
index a5a4a35b13ca..491b35890c0c 100644
--- a/test/std/numerics/complex.number/cmplx.over/real.pass.cpp
+++ b/test/std/numerics/complex.number/cmplx.over/real.pass.cpp
@@ -30,7 +30,7 @@ test(typename std::enable_if<std::is_integral<T>::value>::type* = 0)
     static_assert(std::real(val) == val, "");
     constexpr std::complex<T> t{val, val};
     static_assert(t.real() == x, "" );
-#endif    
+#endif
 }
 
 template <class T, int x>
@@ -44,7 +44,7 @@ test(typename std::enable_if<!std::is_integral<T>::value>::type* = 0)
     static_assert(std::real(val) == val, "");
     constexpr std::complex<T> t{val, val};
     static_assert(t.real() == x, "" );
-#endif    
+#endif
 }
 
 template <class T>
diff --git a/test/std/numerics/complex.number/complex.literals/literals.pass.cpp b/test/std/numerics/complex.number/complex.literals/literals.pass.cpp
index 45b59914e7f8..a2e53629f97d 100644
--- a/test/std/numerics/complex.number/complex.literals/literals.pass.cpp
+++ b/test/std/numerics/complex.number/complex.literals/literals.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <chrono>
 
 #include <complex>
@@ -15,7 +16,6 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11 
     using namespace std::literals::complex_literals;
 
 //  Make sure the types are right
@@ -25,14 +25,14 @@ int main()
     static_assert ( std::is_same<decltype( 3i    ), std::complex<double>>::value, "" );
     static_assert ( std::is_same<decltype( 3.0if ), std::complex<float>>::value, "" );
     static_assert ( std::is_same<decltype( 3if   ), std::complex<float>>::value, "" );
-    
+
     {
     std::complex<long double> c1 = 3.0il;
     assert ( c1 == std::complex<long double>(0, 3.0));
     auto c2 = 3il;
     assert ( c1 == c2 );
     }
-    
+
     {
     std::complex<double> c1 = 3.0i;
     assert ( c1 == std::complex<double>(0, 3.0));
@@ -46,6 +46,4 @@ int main()
     auto c2 = 3if;
     assert ( c1 == c2 );
     }
-
-#endif
 }
diff --git a/test/std/numerics/complex.number/complex.literals/literals1.fail.cpp b/test/std/numerics/complex.number/complex.literals/literals1.fail.cpp
index 0f31d595566c..67e0fa131fd0 100644
--- a/test/std/numerics/complex.number/complex.literals/literals1.fail.cpp
+++ b/test/std/numerics/complex.number/complex.literals/literals1.fail.cpp
@@ -7,14 +7,12 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
 #include <complex>
 #include <cassert>
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11 
     std::complex<float> foo  = 1.0if;  // should fail w/conversion operator not found
-#else
-#error
-#endif
 }
diff --git a/test/std/numerics/complex.number/complex.literals/literals1.pass.cpp b/test/std/numerics/complex.number/complex.literals/literals1.pass.cpp
index 46903bbd565d..09a6f270f759 100644
--- a/test/std/numerics/complex.number/complex.literals/literals1.pass.cpp
+++ b/test/std/numerics/complex.number/complex.literals/literals1.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <chrono>
 
 #include <complex>
@@ -15,7 +16,6 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11 
     using namespace std::literals;
 
     {
@@ -24,7 +24,7 @@ int main()
     auto c2 = 3il;
     assert ( c1 == c2 );
     }
-    
+
     {
     std::complex<double> c1 = 3.0i;
     assert ( c1 == std::complex<double>(0, 3.0));
@@ -38,6 +38,4 @@ int main()
     auto c2 = 3if;
     assert ( c1 == c2 );
     }
-
-#endif
 }
diff --git a/test/std/numerics/complex.number/complex.literals/literals2.pass.cpp b/test/std/numerics/complex.number/complex.literals/literals2.pass.cpp
index 8bd8acd981bc..d11530d7803a 100644
--- a/test/std/numerics/complex.number/complex.literals/literals2.pass.cpp
+++ b/test/std/numerics/complex.number/complex.literals/literals2.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <chrono>
 
 #include <complex>
@@ -15,7 +16,6 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11 
     using namespace std;
 
     {
@@ -24,7 +24,7 @@ int main()
     auto c2 = 3il;
     assert ( c1 == c2 );
     }
-    
+
     {
     std::complex<double> c1 = 3.0i;
     assert ( c1 == std::complex<double>(0, 3.0));
@@ -38,6 +38,4 @@ int main()
     auto c2 = 3if;
     assert ( c1 == c2 );
     }
-
-#endif
 }
diff --git a/test/std/numerics/complex.number/complex.member.ops/divide_equal_complex.pass.cpp b/test/std/numerics/complex.number/complex.member.ops/divide_equal_complex.pass.cpp
index cb285117b15d..b4200fc81d40 100644
--- a/test/std/numerics/complex.number/complex.member.ops/divide_equal_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.member.ops/divide_equal_complex.pass.cpp
@@ -28,7 +28,7 @@ test()
     c /= c2;
     assert(c.real() == 1);
     assert(c.imag() == 0);
-    
+
     std::complex<T> c3;
 
     c3 = c;
@@ -36,13 +36,13 @@ test()
     c3 /= ic;
     assert(c3.real() ==  0.5);
     assert(c3.imag() == -0.5);
-    
+
     c3 = c;
     std::complex<float> fc (1,1);
     c3 /= fc;
     assert(c3.real() ==  0.5);
     assert(c3.imag() == -0.5);
-    
+
 }
 
 int main()
diff --git a/test/std/numerics/complex.number/complex.member.ops/plus_equal_complex.pass.cpp b/test/std/numerics/complex.number/complex.member.ops/plus_equal_complex.pass.cpp
index 8c16f4ced2cd..9b222b8a1d3c 100644
--- a/test/std/numerics/complex.number/complex.member.ops/plus_equal_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.member.ops/plus_equal_complex.pass.cpp
@@ -36,7 +36,7 @@ test()
     c3 += ic;
     assert(c3.real() == 4);
     assert(c3.imag() == 6);
-    
+
     c3 = c;
     std::complex<float> fc (1,1);
     c3 += fc;
diff --git a/test/std/numerics/complex.number/complex.member.ops/times_equal_complex.pass.cpp b/test/std/numerics/complex.number/complex.member.ops/times_equal_complex.pass.cpp
index 84d6e591306e..98b7197cb272 100644
--- a/test/std/numerics/complex.number/complex.member.ops/times_equal_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.member.ops/times_equal_complex.pass.cpp
@@ -36,7 +36,7 @@ test()
     c3 *= ic;
     assert(c3.real() == -11.5);
     assert(c3.imag() ==   3.5);
-    
+
     c3 = c;
     std::complex<float> fc (1,1);
     c3 *= fc;
diff --git a/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp b/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp
index 86119678aa70..8d4712eece78 100644
--- a/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp
@@ -37,16 +37,16 @@ test()
 
 void test_edges()
 {
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
         for (unsigned j = 0; j < N; ++j)
         {
-            std::complex<double> r = x[i] / x[j];
-            switch (classify(x[i]))
+            std::complex<double> r = testcases[i] / testcases[j];
+            switch (classify(testcases[i]))
             {
             case zero:
-                switch (classify(x[j]))
+                switch (classify(testcases[j]))
                 {
                 case zero:
                     assert(classify(r) == NaN);
@@ -66,7 +66,7 @@ void test_edges()
                 }
                 break;
             case non_zero:
-                switch (classify(x[j]))
+                switch (classify(testcases[j]))
                 {
                 case zero:
                     assert(classify(r) == inf);
@@ -86,7 +86,7 @@ void test_edges()
                 }
                 break;
             case inf:
-                switch (classify(x[j]))
+                switch (classify(testcases[j]))
                 {
                 case zero:
                     assert(classify(r) == inf);
@@ -106,7 +106,7 @@ void test_edges()
                 }
                 break;
             case NaN:
-                switch (classify(x[j]))
+                switch (classify(testcases[j]))
                 {
                 case zero:
                     assert(classify(r) == NaN);
@@ -126,7 +126,7 @@ void test_edges()
                 }
                 break;
             case non_zero_nan:
-                switch (classify(x[j]))
+                switch (classify(testcases[j]))
                 {
                 case zero:
                     assert(classify(r) == inf);
diff --git a/test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp b/test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp
index 565eaa5657cd..8ead5bfb627a 100644
--- a/test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp
@@ -39,16 +39,16 @@ test()
 
 void test_edges()
 {
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
         for (unsigned j = 0; j < N; ++j)
         {
-            std::complex<double> r = x[i] * x[j];
-            switch (classify(x[i]))
+            std::complex<double> r = testcases[i] * testcases[j];
+            switch (classify(testcases[i]))
             {
             case zero:
-                switch (classify(x[j]))
+                switch (classify(testcases[j]))
                 {
                 case zero:
                     assert(classify(r) == zero);
@@ -68,7 +68,7 @@ void test_edges()
                 }
                 break;
             case non_zero:
-                switch (classify(x[j]))
+                switch (classify(testcases[j]))
                 {
                 case zero:
                     assert(classify(r) == zero);
@@ -88,7 +88,7 @@ void test_edges()
                 }
                 break;
             case inf:
-                switch (classify(x[j]))
+                switch (classify(testcases[j]))
                 {
                 case zero:
                     assert(classify(r) == NaN);
@@ -108,7 +108,7 @@ void test_edges()
                 }
                 break;
             case NaN:
-                switch (classify(x[j]))
+                switch (classify(testcases[j]))
                 {
                 case zero:
                     assert(classify(r) == NaN);
@@ -128,7 +128,7 @@ void test_edges()
                 }
                 break;
             case non_zero_nan:
-                switch (classify(x[j]))
+                switch (classify(testcases[j]))
                 {
                 case zero:
                     assert(classify(r) == NaN);
diff --git a/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp
index f8ee306d7544..1b0cca0d5f69 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp
@@ -36,94 +36,94 @@ void test_edges()
 {
     typedef std::complex<double> C;
     const double pi = std::atan2(+0., -0.);
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        std::complex<double> r = acos(x[i]);
-        if (x[i].real() == 0 && x[i].imag() == 0)
+        std::complex<double> r = acos(testcases[i]);
+        if (testcases[i].real() == 0 && testcases[i].imag() == 0)
         {
             is_about(r.real(), pi/2);
             assert(r.imag() == 0);
-            assert(std::signbit(x[i].imag()) != std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) != std::signbit(r.imag()));
         }
-        else if (x[i].real() == 0 && std::isnan(x[i].imag()))
+        else if (testcases[i].real() == 0 && std::isnan(testcases[i].imag()))
         {
             is_about(r.real(), pi/2);
             assert(std::isnan(r.imag()));
         }
-        else if (std::isfinite(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             is_about(r.real(), pi/2);
             assert(std::isinf(r.imag()));
-            assert(std::signbit(x[i].imag()) != std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) != std::signbit(r.imag()));
         }
-        else if (std::isfinite(x[i].real()) && x[i].real() != 0 && std::isnan(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && testcases[i].real() != 0 && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && x[i].real() < 0 && std::isfinite(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isfinite(testcases[i].imag()))
         {
             is_about(r.real(), pi);
             assert(std::isinf(r.imag()));
-            assert(std::signbit(x[i].imag()) != std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) != std::signbit(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && x[i].real() > 0 && std::isfinite(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isfinite(testcases[i].imag()))
         {
             assert(r.real() == 0);
             assert(!std::signbit(r.real()));
             assert(std::isinf(r.imag()));
-            assert(std::signbit(x[i].imag()) != std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) != std::signbit(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && x[i].real() < 0 && std::isinf(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isinf(testcases[i].imag()))
         {
             is_about(r.real(), 0.75 * pi);
             assert(std::isinf(r.imag()));
-            assert(std::signbit(x[i].imag()) != std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) != std::signbit(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && x[i].real() > 0 && std::isinf(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isinf(testcases[i].imag()))
         {
             is_about(r.real(), 0.25 * pi);
             assert(std::isinf(r.imag()));
-            assert(std::signbit(x[i].imag()) != std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) != std::signbit(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isinf(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isfinite(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isfinite(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isinf(r.imag()));
-            assert(std::signbit(x[i].imag()) != std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) != std::signbit(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (!std::signbit(x[i].real()) && !std::signbit(x[i].imag()))
+        else if (!std::signbit(testcases[i].real()) && !std::signbit(testcases[i].imag()))
         {
             assert(!std::signbit(r.real()));
             assert( std::signbit(r.imag()));
         }
-        else if (std::signbit(x[i].real()) && !std::signbit(x[i].imag()))
+        else if (std::signbit(testcases[i].real()) && !std::signbit(testcases[i].imag()))
         {
             assert(!std::signbit(r.real()));
             assert( std::signbit(r.imag()));
         }
-        else if (std::signbit(x[i].real()) && std::signbit(x[i].imag()))
+        else if (std::signbit(testcases[i].real()) && std::signbit(testcases[i].imag()))
         {
             assert(!std::signbit(r.real()));
             assert(!std::signbit(r.imag()));
         }
-        else if (!std::signbit(x[i].real()) && std::signbit(x[i].imag()))
+        else if (!std::signbit(testcases[i].real()) && std::signbit(testcases[i].imag()))
         {
             assert(!std::signbit(r.real()));
             assert(!std::signbit(r.imag()));
diff --git a/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp
index 88a5c798424d..f1aece20e6cf 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp
@@ -36,91 +36,91 @@ void test_edges()
 {
     typedef std::complex<double> C;
     const double pi = std::atan2(+0., -0.);
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        std::complex<double> r = acosh(x[i]);
-        if (x[i].real() == 0 && x[i].imag() == 0)
+        std::complex<double> r = acosh(testcases[i]);
+        if (testcases[i].real() == 0 && testcases[i].imag() == 0)
         {
             assert(!std::signbit(r.real()));
-            if (std::signbit(x[i].imag()))
+            if (std::signbit(testcases[i].imag()))
                 is_about(r.imag(), -pi/2);
             else
                 is_about(r.imag(),  pi/2);
         }
-        else if (x[i].real() == 1 && x[i].imag() == 0)
+        else if (testcases[i].real() == 1 && testcases[i].imag() == 0)
         {
             assert(r.real() == 0);
             assert(!std::signbit(r.real()));
             assert(r.imag() == 0);
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
-        else if (std::isfinite(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(r.real() > 0);
-            if (std::signbit(x[i].imag()))
+            if (std::signbit(testcases[i].imag()))
                 is_about(r.imag(), -pi/2);
             else
                 is_about(r.imag(),  pi/2);
         }
-        else if (std::isfinite(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && x[i].real() < 0 && std::isfinite(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isfinite(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(r.real() > 0);
-            if (std::signbit(x[i].imag()))
+            if (std::signbit(testcases[i].imag()))
                 is_about(r.imag(), -pi);
             else
                 is_about(r.imag(),  pi);
         }
-        else if (std::isinf(x[i].real()) && x[i].real() > 0 && std::isfinite(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isfinite(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(r.real() > 0);
             assert(r.imag() == 0);
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
-        else if (std::isinf(x[i].real()) && x[i].real() < 0 && std::isinf(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isinf(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(r.real() > 0);
-            if (std::signbit(x[i].imag()))
+            if (std::signbit(testcases[i].imag()))
                 is_about(r.imag(), -0.75 * pi);
             else
                 is_about(r.imag(),  0.75 * pi);
         }
-        else if (std::isinf(x[i].real()) && x[i].real() > 0 && std::isinf(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isinf(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(r.real() > 0);
-            if (std::signbit(x[i].imag()))
+            if (std::signbit(testcases[i].imag()))
                 is_about(r.imag(), -0.25 * pi);
             else
                 is_about(r.imag(),  0.25 * pi);
         }
-        else if (std::isinf(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(r.real() > 0);
             assert(std::isnan(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isfinite(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isfinite(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(r.real() > 0);
             assert(std::isnan(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
@@ -128,7 +128,7 @@ void test_edges()
         else
         {
             assert(!std::signbit(r.real()));
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
     }
 }
diff --git a/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp
index c743be6488c6..cf6f7869bd1a 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp
@@ -36,77 +36,77 @@ void test_edges()
 {
     typedef std::complex<double> C;
     const double pi = std::atan2(+0., -0.);
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        std::complex<double> r = asin(x[i]);
-        if (x[i].real() == 0 && x[i].imag() == 0)
+        std::complex<double> r = asin(testcases[i]);
+        if (testcases[i].real() == 0 && testcases[i].imag() == 0)
         {
-            assert(std::signbit(r.real()) == std::signbit(x[i].real()));
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
-        else if (std::isfinite(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(r.real() == 0);
-            assert(std::signbit(x[i].real()) == std::signbit(r.real()));
+            assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
             assert(std::isinf(r.imag()));
-            assert(std::signbit(x[i].imag()) == std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
         }
-        else if ( x[i].real() == 0 && std::isnan(x[i].imag()))
+        else if ( testcases[i].real() == 0 && std::isnan(testcases[i].imag()))
         {
             assert(r.real() == 0);
-            assert(std::signbit(x[i].real()) == std::signbit(r.real()));
+            assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isfinite(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && std::isfinite(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isfinite(testcases[i].imag()))
         {
-            if (x[i].real() > 0)
+            if (testcases[i].real() > 0)
                 is_about(r.real(),  pi/2);
             else
                 is_about(r.real(), - pi/2);
             assert(std::isinf(r.imag()));
-            assert(std::signbit(x[i].imag()) == std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
-            if (std::signbit(x[i].real()))
+            if (std::signbit(testcases[i].real()))
                 is_about(r.real(), -pi/4);
             else
                 is_about(r.real(),  pi/4);
             assert(std::isinf(r.imag()));
-            assert(std::signbit(x[i].imag()) == std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isinf(r.imag()));
-            assert(std::signbit(x[i].real()) != std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].real()) != std::signbit(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isfinite(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isfinite(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
-            assert(std::signbit(x[i].imag()) == std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isinf(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
         else
         {
-            assert(std::signbit(r.real()) == std::signbit(x[i].real()));
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
     }
 }
diff --git a/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp
index 027bc6a98a99..011f9d6b4f2e 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp
@@ -36,76 +36,76 @@ void test_edges()
 {
     typedef std::complex<double> C;
     const double pi = std::atan2(+0., -0.);
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        std::complex<double> r = asinh(x[i]);
-        if (x[i].real() == 0 && x[i].imag() == 0)
+        std::complex<double> r = asinh(testcases[i]);
+        if (testcases[i].real() == 0 && testcases[i].imag() == 0)
         {
-            assert(std::signbit(r.real()) == std::signbit(x[i].real()));
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
-        else if (std::isfinite(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
-            assert(std::signbit(x[i].real()) == std::signbit(r.real()));
-            if (std::signbit(x[i].imag()))
+            assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
+            if (std::signbit(testcases[i].imag()))
                 is_about(r.imag(), -pi/2);
             else
                 is_about(r.imag(),  pi/2);
         }
-        else if (std::isfinite(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && std::isfinite(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isfinite(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
-            assert(std::signbit(x[i].real()) == std::signbit(r.real()));
+            assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
             assert(r.imag() == 0);
-            assert(std::signbit(x[i].imag()) == std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
-            assert(std::signbit(x[i].real()) == std::signbit(r.real()));
-            if (std::signbit(x[i].imag()))
+            assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
+            if (std::signbit(testcases[i].imag()))
                 is_about(r.imag(), -pi/4);
             else
                 is_about(r.imag(),  pi/4);
         }
-        else if (std::isinf(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
-            assert(std::signbit(x[i].real()) == std::signbit(r.real()));
+            assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && x[i].imag() == 0)
+        else if (std::isnan(testcases[i].real()) && testcases[i].imag() == 0)
         {
             assert(std::isnan(r.real()));
             assert(r.imag() == 0);
-            assert(std::signbit(x[i].imag()) == std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isfinite(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isfinite(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
         else
         {
-            assert(std::signbit(r.real()) == std::signbit(x[i].real()));
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
     }
 }
diff --git a/test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp
index 69bc95240141..8cc71f7bff27 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp
@@ -35,11 +35,11 @@ test()
 void test_edges()
 {
     typedef std::complex<double> C;
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        std::complex<double> r = atan(x[i]);
-        std::complex<double> t1(-imag(x[i]), real(x[i]));
+        std::complex<double> r = atan(testcases[i]);
+        std::complex<double> t1(-imag(testcases[i]), real(testcases[i]));
         std::complex<double> t2 = atanh(t1);
         std::complex<double> z(imag(t2), -real(t2));
         if (std::isnan(real(r)))
diff --git a/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp
index b821109b751b..6dc6034ca3c6 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp
@@ -36,89 +36,89 @@ void test_edges()
 {
     typedef std::complex<double> C;
     const double pi = std::atan2(+0., -0.);
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        std::complex<double> r = atanh(x[i]);
-        if (x[i].real() == 0 && x[i].imag() == 0)
+        std::complex<double> r = atanh(testcases[i]);
+        if (testcases[i].real() == 0 && testcases[i].imag() == 0)
         {
-            assert(std::signbit(r.real()) == std::signbit(x[i].real()));
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
-        else if ( x[i].real() == 0 && std::isnan(x[i].imag()))
+        else if ( testcases[i].real() == 0 && std::isnan(testcases[i].imag()))
         {
             assert(r.real() == 0);
-            assert(std::signbit(x[i].real()) == std::signbit(r.real()));
+            assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::abs(x[i].real()) == 1 && x[i].imag() == 0)
+        else if (std::abs(testcases[i].real()) == 1 && testcases[i].imag() == 0)
         {
             assert(std::isinf(r.real()));
-            assert(std::signbit(x[i].real()) == std::signbit(r.real()));
+            assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
             assert(r.imag() == 0);
-            assert(std::signbit(x[i].imag()) == std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
         }
-        else if (std::isfinite(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(r.real() == 0);
-            assert(std::signbit(x[i].real()) == std::signbit(r.real()));
-            if (x[i].imag() > 0)
+            assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
+            if (testcases[i].imag() > 0)
                 is_about(r.imag(),  pi/2);
             else
                 is_about(r.imag(), -pi/2);
         }
-        else if (std::isfinite(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && std::isfinite(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isfinite(testcases[i].imag()))
         {
             assert(r.real() == 0);
-            assert(std::signbit(x[i].real()) == std::signbit(r.real()));
-            if (std::signbit(x[i].imag()))
+            assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
+            if (std::signbit(testcases[i].imag()))
                 is_about(r.imag(), -pi/2);
             else
                 is_about(r.imag(),  pi/2);
         }
-        else if (std::isinf(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(r.real() == 0);
-            assert(std::signbit(x[i].real()) == std::signbit(r.real()));
-            if (std::signbit(x[i].imag()))
+            assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
+            if (std::signbit(testcases[i].imag()))
                 is_about(r.imag(), -pi/2);
             else
                 is_about(r.imag(),  pi/2);
         }
-        else if (std::isinf(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(r.real() == 0);
-            assert(std::signbit(x[i].real()) == std::signbit(r.real()));
+            assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isfinite(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isfinite(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(r.real() == 0);
-            assert(std::signbit(x[i].real()) == std::signbit(r.real()));
-            if (std::signbit(x[i].imag()))
+            assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
+            if (std::signbit(testcases[i].imag()))
                 is_about(r.imag(), -pi/2);
             else
                 is_about(r.imag(),  pi/2);
         }
-        else if (std::isnan(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
         else
         {
-            assert(std::signbit(r.real()) == std::signbit(x[i].real()));
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
     }
 }
diff --git a/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp
index f25c967cb1a7..e09163a7057d 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp
@@ -36,11 +36,11 @@ void test_edges()
 {
     typedef std::complex<double> C;
     const double pi = std::atan2(+0., -0.);
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        std::complex<double> r = cos(x[i]);
-        std::complex<double> t1(-imag(x[i]), real(x[i]));
+        std::complex<double> r = cos(testcases[i]);
+        std::complex<double> t1(-imag(testcases[i]), real(testcases[i]));
         std::complex<double> z = cosh(t1);
         if (std::isnan(real(r)))
             assert(std::isnan(real(z)));
diff --git a/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp
index acf4746389c8..0fd9cf79bcbf 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp
@@ -36,72 +36,72 @@ void test_edges()
 {
     typedef std::complex<double> C;
     const double pi = std::atan2(+0., -0.);
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        std::complex<double> r = cosh(x[i]);
-        if (x[i].real() == 0 && x[i].imag() == 0)
+        std::complex<double> r = cosh(testcases[i]);
+        if (testcases[i].real() == 0 && testcases[i].imag() == 0)
         {
             assert(r.real() == 1);
             assert(r.imag() == 0);
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
-        else if (x[i].real() == 0 && std::isinf(x[i].imag()))
+        else if (testcases[i].real() == 0 && std::isinf(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(r.imag() == 0);
         }
-        else if (x[i].real() == 0 && std::isnan(x[i].imag()))
+        else if (testcases[i].real() == 0 && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(r.imag() == 0);
         }
-        else if (std::isfinite(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isfinite(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && x[i].imag() == 0)
+        else if (std::isinf(testcases[i].real()) && testcases[i].imag() == 0)
         {
             assert(std::isinf(r.real()));
             assert(!std::signbit(r.real()));
             assert(r.imag() == 0);
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
-        else if (std::isinf(x[i].real()) && std::isfinite(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isfinite(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
-            assert(std::signbit(r.real()) == std::signbit(cos(x[i].imag())));
+            assert(std::signbit(r.real()) == std::signbit(cos(testcases[i].imag())));
             assert(std::isinf(r.imag()));
-            assert(std::signbit(r.imag()) == std::signbit(x[i].real() * sin(x[i].imag())));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].real() * sin(testcases[i].imag())));
         }
-        else if (std::isinf(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(r.real() > 0);
             assert(std::isnan(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && x[i].imag() == 0)
+        else if (std::isnan(testcases[i].real()) && testcases[i].imag() == 0)
         {
             assert(std::isnan(r.real()));
             assert(r.imag() == 0);
         }
-        else if (std::isnan(x[i].real()) && std::isfinite(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isfinite(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
diff --git a/test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp
index e8b507572f1b..31317816fae0 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp
@@ -34,73 +34,73 @@ test()
 
 void test_edges()
 {
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        std::complex<double> r = exp(x[i]);
-        if (x[i].real() == 0 && x[i].imag() == 0)
+        std::complex<double> r = exp(testcases[i]);
+        if (testcases[i].real() == 0 && testcases[i].imag() == 0)
         {
             assert(r.real() == 1.0);
             assert(r.imag() == 0);
-            assert(std::signbit(x[i].imag()) == std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
         }
-        else if (std::isfinite(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isfinite(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && x[i].real() > 0 && x[i].imag() == 0)
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && testcases[i].imag() == 0)
         {
             assert(std::isinf(r.real()));
             assert(r.real() > 0);
             assert(r.imag() == 0);
-            assert(std::signbit(x[i].imag()) == std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && x[i].real() < 0 && std::isinf(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isinf(testcases[i].imag()))
         {
             assert(r.real() == 0);
             assert(r.imag() == 0);
         }
-        else if (std::isinf(x[i].real()) && x[i].real() > 0 && std::isinf(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isinf(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && x[i].real() < 0 && std::isnan(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isnan(testcases[i].imag()))
         {
             assert(r.real() == 0);
             assert(r.imag() == 0);
         }
-        else if (std::isinf(x[i].real()) && x[i].real() > 0 && std::isnan(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isnan(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && x[i].imag() == 0)
+        else if (std::isnan(testcases[i].real()) && testcases[i].imag() == 0)
         {
             assert(std::isnan(r.real()));
             assert(r.imag() == 0);
-            assert(std::signbit(x[i].imag()) == std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && x[i].imag() != 0)
+        else if (std::isnan(testcases[i].real()) && testcases[i].imag() != 0)
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isfinite(x[i].imag()) && std::abs(x[i].imag()) <= 1)
+        else if (std::isfinite(testcases[i].imag()) && std::abs(testcases[i].imag()) <= 1)
         {
             assert(!std::signbit(r.real()));
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
     }
 }
diff --git a/test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp
index 800b92474bf0..589b5969950d 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp
@@ -35,17 +35,17 @@ test()
 void test_edges()
 {
     const double pi = std::atan2(+0., -0.);
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        std::complex<double> r = log(x[i]);
-        if (x[i].real() == 0 && x[i].imag() == 0)
+        std::complex<double> r = log(testcases[i]);
+        if (testcases[i].real() == 0 && testcases[i].imag() == 0)
         {
-            if (std::signbit(x[i].real()))
+            if (std::signbit(testcases[i].real()))
             {
                 assert(std::isinf(r.real()));
                 assert(r.real() < 0);
-                if (std::signbit(x[i].imag()))
+                if (std::signbit(testcases[i].imag()))
                     is_about(r.imag(), -pi);
                 else
                     is_about(r.imag(), pi);
@@ -55,24 +55,24 @@ void test_edges()
                 assert(std::isinf(r.real()));
                 assert(r.real() < 0);
                 assert(r.imag() == 0);
-                assert(std::signbit(x[i].imag()) == std::signbit(r.imag()));
+                assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
             }
         }
-        else if (std::isfinite(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(r.real() > 0);
-            if (x[i].imag() > 0)
+            if (testcases[i].imag() > 0)
                 is_about(r.imag(), pi/2);
             else
                 is_about(r.imag(), -pi/2);
         }
-        else if (std::isfinite(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && x[i].real() < 0 && std::isfinite(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isfinite(testcases[i].imag()))
         {
             assert(std::isinf(r.real()) && r.real() > 0);
             if (r.imag() > 0)
@@ -80,44 +80,44 @@ void test_edges()
             else
                 is_about(r.imag(), -pi);
         }
-        else if (std::isinf(x[i].real()) && x[i].real() > 0 && std::isfinite(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isfinite(testcases[i].imag()))
         {
             assert(std::isinf(r.real()) && r.real() > 0);
             assert(r.imag() == 0);
-            assert(std::signbit(x[i].imag()) == std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
         }
-        else if (x[i].real() == 1 && x[i].imag() == 0)
+        else if (testcases[i].real() == 1 && testcases[i].imag() == 0)
         {
             assert(r.real() == 0);
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
-        else if (x[i].real() == 0 && x[i].imag() == 1)
+        else if (testcases[i].real() == 0 && testcases[i].imag() == 1)
         {
             assert(r.real() == 0);
             is_about(r.imag(), pi/2);
         }
-        else if (x[i].real() == -1 && x[i].imag() == 0)
+        else if (testcases[i].real() == -1 && testcases[i].imag() == 0)
         {
             assert(r.real() == 0);
-            if (std::signbit(x[i].imag()))
+            if (std::signbit(testcases[i].imag()))
                 is_about(r.imag(), -pi);
             else
                 is_about(r.imag(),  pi);
         }
-        else if (x[i].real() == 0 && x[i].imag() == -1)
+        else if (testcases[i].real() == 0 && testcases[i].imag() == -1)
         {
             assert(r.real() == 0);
             is_about(r.imag(), -pi/2);
         }
-        else if (std::isfinite(x[i].real()) && std::isfinite(x[i].imag()) && abs(x[i]) < 1)
+        else if (std::isfinite(testcases[i].real()) && std::isfinite(testcases[i].imag()) && abs(testcases[i]) < 1)
         {
             assert( std::signbit(r.real()));
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
-        else if (std::isfinite(x[i].real()) && std::isfinite(x[i].imag()) && abs(x[i]) > 1)
+        else if (std::isfinite(testcases[i].real()) && std::isfinite(testcases[i].imag()) && abs(testcases[i]) > 1)
         {
             assert(!std::signbit(r.real()));
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
     }
 }
diff --git a/test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp
index ba03ebf8ad28..58286904ae25 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp
@@ -35,11 +35,11 @@ test()
 void test_edges()
 {
     const double pi = std::atan2(+0., -0.);
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        std::complex<double> r = log10(x[i]);
-        std::complex<double> z = log(x[i])/std::log(10);
+        std::complex<double> r = log10(testcases[i]);
+        std::complex<double> z = log(testcases[i])/std::log(10);
         if (std::isnan(real(r)))
             assert(std::isnan(real(z)));
         else
diff --git a/test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp
index 258193d257a8..157246947cfe 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp
@@ -37,13 +37,13 @@ test()
 void test_edges()
 {
     const double pi = std::atan2(+0., -0.);
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
         for (unsigned j = 0; j < N; ++j)
         {
-            std::complex<double> r = pow(x[i], x[j]);
-            std::complex<double> z = exp(x[j] * log(x[i]));
+            std::complex<double> r = pow(testcases[i], testcases[j]);
+            std::complex<double> z = exp(testcases[j] * log(testcases[i]));
             if (std::isnan(real(r)))
                 assert(std::isnan(real(z)));
             else
diff --git a/test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp
index 03bd10d465d1..0752ea59f554 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp
@@ -37,13 +37,13 @@ test()
 void test_edges()
 {
     const double pi = std::atan2(+0., -0.);
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
         for (unsigned j = 0; j < N; ++j)
         {
-            std::complex<double> r = pow(x[i], real(x[j]));
-            std::complex<double> z = exp(std::complex<double>(real(x[j])) * log(x[i]));
+            std::complex<double> r = pow(testcases[i], real(testcases[j]));
+            std::complex<double> z = exp(std::complex<double>(real(testcases[j])) * log(testcases[i]));
             if (std::isnan(real(r)))
                 assert(std::isnan(real(z)));
             else
diff --git a/test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp
index a48498cea92c..aedeec8caacc 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp
@@ -37,13 +37,13 @@ test()
 void test_edges()
 {
     const double pi = std::atan2(+0., -0.);
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
         for (unsigned j = 0; j < N; ++j)
         {
-            std::complex<double> r = pow(real(x[i]), x[j]);
-            std::complex<double> z = exp(x[j] * log(std::complex<double>(real(x[i]))));
+            std::complex<double> r = pow(real(testcases[i]), testcases[j]);
+            std::complex<double> z = exp(testcases[j] * log(std::complex<double>(real(testcases[i]))));
             if (std::isnan(real(r)))
                 assert(std::isnan(real(z)));
             else
diff --git a/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp
index 068222a27373..e1b98ecd0677 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp
@@ -36,11 +36,11 @@ void test_edges()
 {
     typedef std::complex<double> C;
     const double pi = std::atan2(+0., -0.);
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        std::complex<double> r = sin(x[i]);
-        std::complex<double> t1(-imag(x[i]), real(x[i]));
+        std::complex<double> r = sin(testcases[i]);
+        std::complex<double> t1(-imag(testcases[i]), real(testcases[i]));
         std::complex<double> t2 = sinh(t1);
         std::complex<double> z(imag(t2), -real(t2));
         if (std::isnan(real(r)))
diff --git a/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
index dcd30e48dff5..20f2e71b140a 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
@@ -36,73 +36,73 @@ void test_edges()
 {
     typedef std::complex<double> C;
     const double pi = std::atan2(+0., -0.);
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        std::complex<double> r = sinh(x[i]);
-        if (x[i].real() == 0 && x[i].imag() == 0)
+        std::complex<double> r = sinh(testcases[i]);
+        if (testcases[i].real() == 0 && testcases[i].imag() == 0)
         {
             assert(r.real() == 0);
-            assert(std::signbit(r.real()) == std::signbit(x[i].real()));
+            assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
             assert(r.imag() == 0);
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
-        else if (x[i].real() == 0 && std::isinf(x[i].imag()))
+        else if (testcases[i].real() == 0 && std::isinf(testcases[i].imag()))
         {
             assert(r.real() == 0);
             assert(std::isnan(r.imag()));
         }
-        else if (std::isfinite(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (x[i].real() == 0 && std::isnan(x[i].imag()))
+        else if (testcases[i].real() == 0 && std::isnan(testcases[i].imag()))
         {
             assert(r.real() == 0);
             assert(std::isnan(r.imag()));
         }
-        else if (std::isfinite(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && x[i].imag() == 0)
+        else if (std::isinf(testcases[i].real()) && testcases[i].imag() == 0)
         {
             assert(std::isinf(r.real()));
-            assert(std::signbit(r.real()) == std::signbit(x[i].real()));
+            assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
             assert(r.imag() == 0);
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
-        else if (std::isinf(x[i].real()) && std::isfinite(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isfinite(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
-            assert(std::signbit(r.real()) == std::signbit(x[i].real() * cos(x[i].imag())));
+            assert(std::signbit(r.real()) == std::signbit(testcases[i].real() * cos(testcases[i].imag())));
             assert(std::isinf(r.imag()));
-            assert(std::signbit(r.imag()) == std::signbit(sin(x[i].imag())));
+            assert(std::signbit(r.imag()) == std::signbit(sin(testcases[i].imag())));
         }
-        else if (std::isinf(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && x[i].imag() == 0)
+        else if (std::isnan(testcases[i].real()) && testcases[i].imag() == 0)
         {
             assert(std::isnan(r.real()));
             assert(r.imag() == 0);
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isfinite(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isfinite(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
diff --git a/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp
index 69309d2b9ab1..d3273179a6da 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp
@@ -36,58 +36,58 @@ test()
 
 void test_edges()
 {
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        std::complex<double> r = sqrt(x[i]);
-        if (x[i].real() == 0 && x[i].imag() == 0)
+        std::complex<double> r = sqrt(testcases[i]);
+        if (testcases[i].real() == 0 && testcases[i].imag() == 0)
         {
             assert(!std::signbit(r.real()));
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
-        else if (std::isinf(x[i].imag()))
+        else if (std::isinf(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(r.real() > 0);
             assert(std::isinf(r.imag()));
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
-        else if (std::isfinite(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && x[i].real() < 0 && std::isfinite(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isfinite(testcases[i].imag()))
         {
             assert(r.real() == 0);
             assert(!std::signbit(r.real()));
             assert(std::isinf(r.imag()));
-            assert(std::signbit(x[i].imag()) == std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && x[i].real() > 0 && std::isfinite(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isfinite(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(r.real() > 0);
             assert(r.imag() == 0);
-            assert(std::signbit(x[i].imag()) == std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && x[i].real() < 0 && std::isnan(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isinf(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && x[i].real() > 0 && std::isnan(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isnan(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(r.real() > 0);
             assert(std::isnan(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && (std::isfinite(x[i].imag()) || std::isnan(x[i].imag())))
+        else if (std::isnan(testcases[i].real()) && (std::isfinite(testcases[i].imag()) || std::isnan(testcases[i].imag())))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::signbit(x[i].imag()))
+        else if (std::signbit(testcases[i].imag()))
         {
             assert(!std::signbit(r.real()));
             assert(std::signbit(r.imag()));
diff --git a/test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp
index 881427600686..041a7814d033 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp
@@ -37,11 +37,11 @@ void test_edges()
 {
     typedef std::complex<double> C;
     const double pi = std::atan2(+0., -0.);
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        std::complex<double> r = tan(x[i]);
-        std::complex<double> t1(-imag(x[i]), real(x[i]));
+        std::complex<double> r = tan(testcases[i]);
+        std::complex<double> t1(-imag(testcases[i]), real(testcases[i]));
         std::complex<double> t2 = tanh(t1);
         std::complex<double> z(imag(t2), -real(t2));
         if (std::isnan(real(r)))
diff --git a/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp
index 907c0e64dba9..9a2276a8b753 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp
@@ -36,55 +36,55 @@ void test_edges()
 {
     typedef std::complex<double> C;
     const double pi = std::atan2(+0., -0.);
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        std::complex<double> r = tanh(x[i]);
-        if (x[i].real() == 0 && x[i].imag() == 0)
+        std::complex<double> r = tanh(testcases[i]);
+        if (testcases[i].real() == 0 && testcases[i].imag() == 0)
         {
             assert(r.real() == 0);
-            assert(std::signbit(r.real()) == std::signbit(x[i].real()));
+            assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
             assert(r.imag() == 0);
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
-        else if (std::isfinite(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isfinite(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && std::isfinite(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isfinite(testcases[i].imag()))
         {
             assert(r.real() == 1);
             assert(r.imag() == 0);
-            assert(std::signbit(r.imag()) == std::signbit(sin(2*x[i].imag())));
+            assert(std::signbit(r.imag()) == std::signbit(sin(2*testcases[i].imag())));
         }
-        else if (std::isinf(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(r.real() == 1);
             assert(r.imag() == 0);
         }
-        else if (std::isinf(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(r.real() == 1);
             assert(r.imag() == 0);
         }
-        else if (std::isnan(x[i].real()) && x[i].imag() == 0)
+        else if (std::isnan(testcases[i].real()) && testcases[i].imag() == 0)
         {
             assert(std::isnan(r.real()));
             assert(r.imag() == 0);
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isfinite(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isfinite(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
diff --git a/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp b/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp
index 5d841d6ee9f1..7a0e3bd70072 100644
--- a/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp
+++ b/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp
@@ -28,11 +28,11 @@ test()
 
 void test_edges()
 {
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        double r = abs(x[i]);
-        switch (classify(x[i]))
+        double r = abs(testcases[i]);
+        switch (classify(testcases[i]))
         {
         case zero:
             assert(r == 0);
diff --git a/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp b/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp
index a7da456b979c..78f2781b76e2 100644
--- a/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp
+++ b/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp
@@ -29,42 +29,42 @@ test()
 void test_edges()
 {
     const double pi = std::atan2(+0., -0.);
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        double r = arg(x[i]);
-        if (std::isnan(x[i].real()) || std::isnan(x[i].imag()))
+        double r = arg(testcases[i]);
+        if (std::isnan(testcases[i].real()) || std::isnan(testcases[i].imag()))
             assert(std::isnan(r));
         else
         {
-            switch (classify(x[i]))
+            switch (classify(testcases[i]))
             {
             case zero:
-                if (std::signbit(x[i].real()))
+                if (std::signbit(testcases[i].real()))
                 {
-                    if (std::signbit(x[i].imag()))
+                    if (std::signbit(testcases[i].imag()))
                         is_about(r, -pi);
                     else
                         is_about(r, pi);
                 }
                 else
                 {
-                    assert(std::signbit(x[i].imag()) == std::signbit(r));
+                    assert(std::signbit(testcases[i].imag()) == std::signbit(r));
                 }
                 break;
             case non_zero:
-                if (x[i].real() == 0)
+                if (testcases[i].real() == 0)
                 {
-                    if (x[i].imag() < 0)
+                    if (testcases[i].imag() < 0)
                         is_about(r, -pi/2);
                     else
                         is_about(r, pi/2);
                 }
-                else if (x[i].imag() == 0)
+                else if (testcases[i].imag() == 0)
                 {
-                    if (x[i].real() < 0)
+                    if (testcases[i].real() < 0)
                     {
-                        if (std::signbit(x[i].imag()))
+                        if (std::signbit(testcases[i].imag()))
                             is_about(r, -pi);
                         else
                             is_about(r, pi);
@@ -72,37 +72,37 @@ void test_edges()
                     else
                     {
                         assert(r == 0);
-                        assert(std::signbit(x[i].imag()) == std::signbit(r));
+                        assert(std::signbit(testcases[i].imag()) == std::signbit(r));
                     }
                 }
-                else if (x[i].imag() > 0)
+                else if (testcases[i].imag() > 0)
                     assert(r > 0);
                 else
                     assert(r < 0);
                 break;
             case inf:
-                if (std::isinf(x[i].real()) && std::isinf(x[i].imag()))
+                if (std::isinf(testcases[i].real()) && std::isinf(testcases[i].imag()))
                 {
-                    if (x[i].real() < 0)
+                    if (testcases[i].real() < 0)
                     {
-                        if (x[i].imag() > 0)
+                        if (testcases[i].imag() > 0)
                             is_about(r, 0.75 * pi);
                         else
                             is_about(r, -0.75 * pi);
                     }
                     else
                     {
-                        if (x[i].imag() > 0)
+                        if (testcases[i].imag() > 0)
                             is_about(r, 0.25 * pi);
                         else
                             is_about(r, -0.25 * pi);
                     }
                 }
-                else if (std::isinf(x[i].real()))
+                else if (std::isinf(testcases[i].real()))
                 {
-                    if (x[i].real() < 0)
+                    if (testcases[i].real() < 0)
                     {
-                        if (std::signbit(x[i].imag()))
+                        if (std::signbit(testcases[i].imag()))
                             is_about(r, -pi);
                         else
                             is_about(r, pi);
@@ -110,12 +110,12 @@ void test_edges()
                     else
                     {
                         assert(r == 0);
-                        assert(std::signbit(r) == std::signbit(x[i].imag()));
+                        assert(std::signbit(r) == std::signbit(testcases[i].imag()));
                     }
                 }
                 else
                 {
-                    if (x[i].imag() < 0)
+                    if (testcases[i].imag() < 0)
                         is_about(r, -pi/2);
                     else
                         is_about(r, pi/2);
diff --git a/test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp b/test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp
index 48f774e8e1c9..da7ad14bedce 100644
--- a/test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp
+++ b/test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp
@@ -28,11 +28,11 @@ test()
 
 void test_edges()
 {
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        double r = norm(x[i]);
-        switch (classify(x[i]))
+        double r = norm(testcases[i]);
+        switch (classify(testcases[i]))
         {
         case zero:
             assert(r == 0);
diff --git a/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp b/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp
index a8747bd7c83b..5e6cb0d523c2 100644
--- a/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp
+++ b/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp
@@ -46,11 +46,11 @@ test()
 
 void test_edges()
 {
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        double r = real(x[i]);
-        double theta = imag(x[i]);
+        double r = real(testcases[i]);
+        double theta = imag(testcases[i]);
         std::complex<double> z = std::polar(r, theta);
         switch (classify(r))
         {
diff --git a/test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp b/test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp
index 10bf7f8576f6..1a7e0c53f3d3 100644
--- a/test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp
+++ b/test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp
@@ -37,26 +37,26 @@ test()
 
 void test_edges()
 {
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        std::complex<double> r = proj(x[i]);
-        switch (classify(x[i]))
+        std::complex<double> r = proj(testcases[i]);
+        switch (classify(testcases[i]))
         {
         case zero:
         case non_zero:
-            assert(r == x[i]);
-            assert(std::signbit(real(r)) == std::signbit(real(x[i])));
-            assert(std::signbit(imag(r)) == std::signbit(imag(x[i])));
+            assert(r == testcases[i]);
+            assert(std::signbit(real(r)) == std::signbit(real(testcases[i])));
+            assert(std::signbit(imag(r)) == std::signbit(imag(testcases[i])));
             break;
         case inf:
             assert(std::isinf(real(r)) && real(r) > 0);
             assert(imag(r) == 0);
-            assert(std::signbit(imag(r)) == std::signbit(imag(x[i])));
+            assert(std::signbit(imag(r)) == std::signbit(imag(testcases[i])));
             break;
         case NaN:
         case non_zero_nan:
-            assert(classify(r) == classify(x[i]));
+            assert(classify(r) == classify(testcases[i]));
             break;
         }
     }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.unary/not.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.unary/not.pass.cpp
index 0b792c68fb94..306ea0c18470 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.unary/not.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.unary/not.pass.cpp
@@ -36,6 +36,6 @@ int main()
         std::valarray<bool> v2 = !(v + v);
         assert(v2.size() == v.size());
         for (int i = 0; i < v2.size(); ++i)
-            assert(v2[i] == !2*v[i]);
+            assert(v2[i] == !(2 * v[i]));
     }
 }
diff --git a/test/std/numerics/rand/rand.device/ctor.pass.cpp b/test/std/numerics/rand/rand.device/ctor.pass.cpp
index dfeccc81e30e..8c45bb19a0a6 100644
--- a/test/std/numerics/rand/rand.device/ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.device/ctor.pass.cpp
@@ -22,7 +22,13 @@
 #include <random>
 #include <system_error>
 #include <cassert>
+
+#if !defined(_WIN32)
 #include <unistd.h>
+#endif
+
+#include "test_macros.h"
+
 
 bool is_valid_random_device(const std::string &token) {
 #if defined(_LIBCPP_USING_DEV_RANDOM)
@@ -40,33 +46,20 @@ void check_random_device_valid(const std::string &token) {
 void check_random_device_invalid(const std::string &token) {
   try {
     std::random_device r(token);
-    assert(false);
-  } catch (const std::system_error &e) {
+    LIBCPP_ASSERT(false);
+  } catch (const std::system_error&) {
   }
 }
 
-int main() {
-  { std::random_device r; }
 
+int main() {
   {
-    int ec;
-    ec = close(STDIN_FILENO);
-    assert(!ec);
-    ec = close(STDOUT_FILENO);
-    assert(!ec);
-    ec = close(STDERR_FILENO);
-    assert(!ec);
     std::random_device r;
   }
-
   {
     std::string token = "wrong file";
-    if (is_valid_random_device(token))
-      check_random_device_valid(token);
-    else
-      check_random_device_invalid(token);
+    check_random_device_invalid(token);
   }
-
   {
     std::string token = "/dev/urandom";
     if (is_valid_random_device(token))
@@ -74,7 +67,6 @@ int main() {
     else
       check_random_device_invalid(token);
   }
-
   {
     std::string token = "/dev/random";
     if (is_valid_random_device(token))
@@ -82,4 +74,19 @@ int main() {
     else
       check_random_device_invalid(token);
   }
+#if !defined(_WIN32)
+// Test that random_device(const string&) properly handles getting
+// a file descriptor with the value '0'. Do this by closing the standard
+// streams so that the descriptor '0' is available.
+  {
+    int ec;
+    ec = close(STDIN_FILENO);
+    assert(!ec);
+    ec = close(STDOUT_FILENO);
+    assert(!ec);
+    ec = close(STDERR_FILENO);
+    assert(!ec);
+    std::random_device r;
+  }
+#endif // !defined(_WIN32)
 }
diff --git a/test/std/numerics/rand/rand.device/eval.pass.cpp b/test/std/numerics/rand/rand.device/eval.pass.cpp
index ed5361fbde75..eabcc201e068 100644
--- a/test/std/numerics/rand/rand.device/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.device/eval.pass.cpp
@@ -17,6 +17,8 @@
 #include <random>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
     {
@@ -28,9 +30,9 @@ int main()
     {
         std::random_device r("/dev/null");
         r();
-        assert(false);
+        LIBCPP_ASSERT(false);
     }
-    catch (const std::system_error& e)
+    catch (const std::system_error&)
     {
     }
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eval.pass.cpp
index f071e8507478..b267c2477e91 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eval.pass.cpp
@@ -44,10 +44,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -80,10 +80,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eval_param.pass.cpp
index e03fb57f380c..f96df82304f0 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eval_param.pass.cpp
@@ -46,10 +46,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -84,10 +84,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp
index 43c6b546bdb2..88004ba4a741 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp
@@ -29,447 +29,491 @@ sqr(T x)
     return x * x;
 }
 
-int main()
+void
+test1()
 {
+    typedef std::binomial_distribution<> D;
+    typedef std::mt19937_64 G;
+    G g;
+    D d(5, .75);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
     {
-        typedef std::binomial_distribution<> D;
-        typedef std::mt19937_64 G;
-        G g;
-        D d(5, .75);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = d.t() * d.p();
-        double x_var = x_mean*(1-d.p());
-        double x_skew = (1-2*d.p()) / std::sqrt(x_var);
-        double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.04);
+        D::result_type v = d(g);
+        assert(d.min() <= v && v <= d.max());
+        u.push_back(v);
     }
+    double mean = std::accumulate(u.begin(), u.end(),
+                                          double(0)) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
     {
-        typedef std::binomial_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(30, .03125);
-        const int N = 100000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = d.t() * d.p();
-        double x_var = x_mean*(1-d.p());
-        double x_skew = (1-2*d.p()) / std::sqrt(x_var);
-        double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
     }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = d.t() * d.p();
+    double x_var = x_mean*(1-d.p());
+    double x_skew = (1-2*d.p()) / std::sqrt(x_var);
+    double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
+    assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+    assert(std::abs((var - x_var) / x_var) < 0.01);
+    assert(std::abs((skew - x_skew) / x_skew) < 0.01);
+    assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.04);
+}
+
+void
+test2()
+{
+    typedef std::binomial_distribution<> D;
+    typedef std::mt19937 G;
+    G g;
+    D d(30, .03125);
+    const int N = 100000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
     {
-        typedef std::binomial_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(40, .25);
-        const int N = 100000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = d.t() * d.p();
-        double x_var = x_mean*(1-d.p());
-        double x_skew = (1-2*d.p()) / std::sqrt(x_var);
-        double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.03);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.3);
+        D::result_type v = d(g);
+        assert(d.min() <= v && v <= d.max());
+        u.push_back(v);
     }
+    double mean = std::accumulate(u.begin(), u.end(),
+                                          double(0)) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
     {
-        typedef std::binomial_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(40, 0);
-        const int N = 100000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        // In this case:
-        //   skew     computes to 0./0. == nan
-        //   kurtosis computes to 0./0. == nan
-        //   x_skew     == inf
-        //   x_kurtosis == inf
-        //   These tests are commented out because UBSan warns about division by 0
-//        skew /= u.size() * dev * var;
-//        kurtosis /= u.size() * var * var;
-//        kurtosis -= 3;
-        double x_mean = d.t() * d.p();
-        double x_var = x_mean*(1-d.p());
-//        double x_skew = (1-2*d.p()) / std::sqrt(x_var);
-//        double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
-        assert(mean == x_mean);
-        assert(var == x_var);
-//        assert(skew == x_skew);
-//        assert(kurtosis == x_kurtosis);
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
     }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = d.t() * d.p();
+    double x_var = x_mean*(1-d.p());
+    double x_skew = (1-2*d.p()) / std::sqrt(x_var);
+    double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
+    assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+    assert(std::abs((var - x_var) / x_var) < 0.01);
+    assert(std::abs((skew - x_skew) / x_skew) < 0.01);
+    assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+}
+
+void
+test3()
+{
+    typedef std::binomial_distribution<> D;
+    typedef std::mt19937 G;
+    G g;
+    D d(40, .25);
+    const int N = 100000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
     {
-        typedef std::binomial_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(40, 1);
-        const int N = 100000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        // In this case:
-        //   skew     computes to 0./0. == nan
-        //   kurtosis computes to 0./0. == nan
-        //   x_skew     == -inf
-        //   x_kurtosis == inf
-        //   These tests are commented out because UBSan warns about division by 0
-//        skew /= u.size() * dev * var;
-//        kurtosis /= u.size() * var * var;
-//        kurtosis -= 3;
-        double x_mean = d.t() * d.p();
-        double x_var = x_mean*(1-d.p());
-//        double x_skew = (1-2*d.p()) / std::sqrt(x_var);
-//        double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
-        assert(mean == x_mean);
-        assert(var == x_var);
-//        assert(skew == x_skew);
-//        assert(kurtosis == x_kurtosis);
+        D::result_type v = d(g);
+        assert(d.min() <= v && v <= d.max());
+        u.push_back(v);
     }
+    double mean = std::accumulate(u.begin(), u.end(),
+                                          double(0)) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
     {
-        typedef std::binomial_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(400, 0.5);
-        const int N = 100000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = d.t() * d.p();
-        double x_var = x_mean*(1-d.p());
-        double x_skew = (1-2*d.p()) / std::sqrt(x_var);
-        double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs(skew - x_skew) < 0.01);
-        assert(std::abs(kurtosis - x_kurtosis) < 0.01);
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
     }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = d.t() * d.p();
+    double x_var = x_mean*(1-d.p());
+    double x_skew = (1-2*d.p()) / std::sqrt(x_var);
+    double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
+    assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+    assert(std::abs((var - x_var) / x_var) < 0.01);
+    assert(std::abs((skew - x_skew) / x_skew) < 0.03);
+    assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.3);
+}
+
+void
+test4()
+{
+    typedef std::binomial_distribution<> D;
+    typedef std::mt19937 G;
+    G g;
+    D d(40, 0);
+    const int N = 100000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
     {
-        typedef std::binomial_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(1, 0.5);
-        const int N = 100000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = d.t() * d.p();
-        double x_var = x_mean*(1-d.p());
-        double x_skew = (1-2*d.p()) / std::sqrt(x_var);
-        double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs(skew - x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+        D::result_type v = d(g);
+        assert(d.min() <= v && v <= d.max());
+        u.push_back(v);
     }
+    double mean = std::accumulate(u.begin(), u.end(),
+                                          double(0)) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
     {
-        const int N = 100000;
-        std::mt19937 gen1;
-        std::mt19937 gen2;
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
+    }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    // In this case:
+    //   skew     computes to 0./0. == nan
+    //   kurtosis computes to 0./0. == nan
+    //   x_skew     == inf
+    //   x_kurtosis == inf
+    //   These tests are commented out because UBSan warns about division by 0
+//    skew /= u.size() * dev * var;
+//    kurtosis /= u.size() * var * var;
+//    kurtosis -= 3;
+    double x_mean = d.t() * d.p();
+    double x_var = x_mean*(1-d.p());
+//    double x_skew = (1-2*d.p()) / std::sqrt(x_var);
+//    double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
+    assert(mean == x_mean);
+    assert(var == x_var);
+//    assert(skew == x_skew);
+//    assert(kurtosis == x_kurtosis);
+}
 
-        std::binomial_distribution<>         dist1(5, 0.1);
-        std::binomial_distribution<unsigned> dist2(5, 0.1);
+void
+test5()
+{
+    typedef std::binomial_distribution<> D;
+    typedef std::mt19937 G;
+    G g;
+    D d(40, 1);
+    const int N = 100000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
+    {
+        D::result_type v = d(g);
+        assert(d.min() <= v && v <= d.max());
+        u.push_back(v);
+    }
+    double mean = std::accumulate(u.begin(), u.end(),
+                                          double(0)) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
+    {
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
+    }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    // In this case:
+    //   skew     computes to 0./0. == nan
+    //   kurtosis computes to 0./0. == nan
+    //   x_skew     == -inf
+    //   x_kurtosis == inf
+    //   These tests are commented out because UBSan warns about division by 0
+//    skew /= u.size() * dev * var;
+//    kurtosis /= u.size() * var * var;
+//    kurtosis -= 3;
+    double x_mean = d.t() * d.p();
+    double x_var = x_mean*(1-d.p());
+//    double x_skew = (1-2*d.p()) / std::sqrt(x_var);
+//    double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
+    assert(mean == x_mean);
+    assert(var == x_var);
+//    assert(skew == x_skew);
+//    assert(kurtosis == x_kurtosis);
+}
 
-        for(int i = 0; i < N; ++i)
-            assert(dist1(gen1) == dist2(gen2));
+void
+test6()
+{
+    typedef std::binomial_distribution<> D;
+    typedef std::mt19937 G;
+    G g;
+    D d(400, 0.5);
+    const int N = 100000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
+    {
+        D::result_type v = d(g);
+        assert(d.min() <= v && v <= d.max());
+        u.push_back(v);
     }
+    double mean = std::accumulate(u.begin(), u.end(),
+                                          double(0)) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
     {
-        typedef std::binomial_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(0, 0.005);
-        const int N = 100000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        // In this case:
-        //   skew     computes to 0./0. == nan
-        //   kurtosis computes to 0./0. == nan
-        //   x_skew     == inf
-        //   x_kurtosis == inf
-        //   These tests are commented out because UBSan warns about division by 0
-//        skew /= u.size() * dev * var;
-//        kurtosis /= u.size() * var * var;
-//        kurtosis -= 3;
-        double x_mean = d.t() * d.p();
-        double x_var = x_mean*(1-d.p());
-//        double x_skew = (1-2*d.p()) / std::sqrt(x_var);
-//        double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
-        assert(mean == x_mean);
-        assert(var == x_var);
-//        assert(skew == x_skew);
-//        assert(kurtosis == x_kurtosis);
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
     }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = d.t() * d.p();
+    double x_var = x_mean*(1-d.p());
+    double x_skew = (1-2*d.p()) / std::sqrt(x_var);
+    double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
+    assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+    assert(std::abs((var - x_var) / x_var) < 0.01);
+    assert(std::abs(skew - x_skew) < 0.01);
+    assert(std::abs(kurtosis - x_kurtosis) < 0.01);
+}
+
+void
+test7()
+{
+    typedef std::binomial_distribution<> D;
+    typedef std::mt19937 G;
+    G g;
+    D d(1, 0.5);
+    const int N = 100000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
     {
-        typedef std::binomial_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(0, 0);
-        const int N = 100000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        // In this case:
-        //   skew     computes to 0./0. == nan
-        //   kurtosis computes to 0./0. == nan
-        //   x_skew     == inf
-        //   x_kurtosis == inf
-        //   These tests are commented out because UBSan warns about division by 0
-//        skew /= u.size() * dev * var;
-//        kurtosis /= u.size() * var * var;
-//        kurtosis -= 3;
-        double x_mean = d.t() * d.p();
-        double x_var = x_mean*(1-d.p());
-//        double x_skew = (1-2*d.p()) / std::sqrt(x_var);
-//        double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
-        assert(mean == x_mean);
-        assert(var == x_var);
-//        assert(skew == x_skew);
-//        assert(kurtosis == x_kurtosis);
+        D::result_type v = d(g);
+        assert(d.min() <= v && v <= d.max());
+        u.push_back(v);
     }
+    double mean = std::accumulate(u.begin(), u.end(),
+                                          double(0)) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
     {
-        typedef std::binomial_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(0, 1);
-        const int N = 100000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        // In this case:
-        //   skew     computes to 0./0. == nan
-        //   kurtosis computes to 0./0. == nan
-        //   x_skew     == -inf
-        //   x_kurtosis == inf
-        //   These tests are commented out because UBSan warns about division by 0
-//        skew /= u.size() * dev * var;
-//        kurtosis /= u.size() * var * var;
-//        kurtosis -= 3;
-        double x_mean = d.t() * d.p();
-        double x_var = x_mean*(1-d.p());
-//        double x_skew = (1-2*d.p()) / std::sqrt(x_var);
-//        double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
-        assert(mean == x_mean);
-        assert(var == x_var);
-//        assert(skew == x_skew);
-//        assert(kurtosis == x_kurtosis);
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
     }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = d.t() * d.p();
+    double x_var = x_mean*(1-d.p());
+    double x_skew = (1-2*d.p()) / std::sqrt(x_var);
+    double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
+    assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+    assert(std::abs((var - x_var) / x_var) < 0.01);
+    assert(std::abs(skew - x_skew) < 0.01);
+    assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+}
+
+void
+test8()
+{
+    const int N = 100000;
+    std::mt19937 gen1;
+    std::mt19937 gen2;
+
+    std::binomial_distribution<>         dist1(5, 0.1);
+    std::binomial_distribution<unsigned> dist2(5, 0.1);
+
+    for(int i = 0; i < N; ++i)
+        assert(dist1(gen1) == dist2(gen2));
+}
+
+void
+test9()
+{
+    typedef std::binomial_distribution<> D;
+    typedef std::mt19937 G;
+    G g;
+    D d(0, 0.005);
+    const int N = 100000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
+    {
+        D::result_type v = d(g);
+        assert(d.min() <= v && v <= d.max());
+        u.push_back(v);
+    }
+    double mean = std::accumulate(u.begin(), u.end(),
+                                          double(0)) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
+    {
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
+    }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    // In this case:
+    //   skew     computes to 0./0. == nan
+    //   kurtosis computes to 0./0. == nan
+    //   x_skew     == inf
+    //   x_kurtosis == inf
+    //   These tests are commented out because UBSan warns about division by 0
+//    skew /= u.size() * dev * var;
+//    kurtosis /= u.size() * var * var;
+//    kurtosis -= 3;
+    double x_mean = d.t() * d.p();
+    double x_var = x_mean*(1-d.p());
+//    double x_skew = (1-2*d.p()) / std::sqrt(x_var);
+//    double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
+    assert(mean == x_mean);
+    assert(var == x_var);
+//    assert(skew == x_skew);
+//    assert(kurtosis == x_kurtosis);
+}
+
+void
+test10()
+{
+    typedef std::binomial_distribution<> D;
+    typedef std::mt19937 G;
+    G g;
+    D d(0, 0);
+    const int N = 100000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
+    {
+        D::result_type v = d(g);
+        assert(d.min() <= v && v <= d.max());
+        u.push_back(v);
+    }
+    double mean = std::accumulate(u.begin(), u.end(),
+                                          double(0)) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
+    {
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
+    }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    // In this case:
+    //   skew     computes to 0./0. == nan
+    //   kurtosis computes to 0./0. == nan
+    //   x_skew     == inf
+    //   x_kurtosis == inf
+    //   These tests are commented out because UBSan warns about division by 0
+//    skew /= u.size() * dev * var;
+//    kurtosis /= u.size() * var * var;
+//    kurtosis -= 3;
+    double x_mean = d.t() * d.p();
+    double x_var = x_mean*(1-d.p());
+//    double x_skew = (1-2*d.p()) / std::sqrt(x_var);
+//    double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
+    assert(mean == x_mean);
+    assert(var == x_var);
+//    assert(skew == x_skew);
+//    assert(kurtosis == x_kurtosis);
+}
+
+void
+test11()
+{
+    typedef std::binomial_distribution<> D;
+    typedef std::mt19937 G;
+    G g;
+    D d(0, 1);
+    const int N = 100000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
+    {
+        D::result_type v = d(g);
+        assert(d.min() <= v && v <= d.max());
+        u.push_back(v);
+    }
+    double mean = std::accumulate(u.begin(), u.end(),
+                                          double(0)) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
+    {
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
+    }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    // In this case:
+    //   skew     computes to 0./0. == nan
+    //   kurtosis computes to 0./0. == nan
+    //   x_skew     == -inf
+    //   x_kurtosis == inf
+    //   These tests are commented out because UBSan warns about division by 0
+//    skew /= u.size() * dev * var;
+//    kurtosis /= u.size() * var * var;
+//    kurtosis -= 3;
+    double x_mean = d.t() * d.p();
+    double x_var = x_mean*(1-d.p());
+//    double x_skew = (1-2*d.p()) / std::sqrt(x_var);
+//    double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
+    assert(mean == x_mean);
+    assert(var == x_var);
+//    assert(skew == x_skew);
+//    assert(kurtosis == x_kurtosis);
+}
+
+int main()
+{
+    test1();
+    test2();
+    test3();
+    test4();
+    test5();
+    test6();
+    test7();
+    test8();
+    test9();
+    test10();
+    test11();
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval_param.pass.cpp
index 1aa66ed57ad1..092a69778513 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval_param.pass.cpp
@@ -53,10 +53,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -95,10 +95,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -137,10 +137,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eval.pass.cpp
index a8ef221e3b67..4e9f9d3c044d 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eval.pass.cpp
@@ -29,246 +29,270 @@ sqr(T x)
     return x * x;
 }
 
-int main()
+void
+test1()
+{
+    typedef std::geometric_distribution<> D;
+    typedef std::mt19937 G;
+    G g;
+    D d(.03125);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
+    {
+        D::result_type v = d(g);
+        assert(d.min() <= v && v <= d.max());
+        u.push_back(v);
+    }
+    double mean = std::accumulate(u.begin(), u.end(),
+                                          double(0)) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
+    {
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
+    }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = (1 - d.p()) / d.p();
+    double x_var = x_mean / d.p();
+    double x_skew = (2 - d.p()) / std::sqrt((1 - d.p()));
+    double x_kurtosis = 6 + sqr(d.p()) / (1 - d.p());
+    assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+    assert(std::abs((var - x_var) / x_var) < 0.01);
+    assert(std::abs((skew - x_skew) / x_skew) < 0.01);
+    assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+}
+
+void
+test2()
+{
+    typedef std::geometric_distribution<> D;
+    typedef std::mt19937 G;
+    G g;
+    D d(0.05);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
+    {
+        D::result_type v = d(g);
+        assert(d.min() <= v && v <= d.max());
+        u.push_back(v);
+    }
+    double mean = std::accumulate(u.begin(), u.end(),
+                                          double(0)) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
+    {
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
+    }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = (1 - d.p()) / d.p();
+    double x_var = x_mean / d.p();
+    double x_skew = (2 - d.p()) / std::sqrt((1 - d.p()));
+    double x_kurtosis = 6 + sqr(d.p()) / (1 - d.p());
+    assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+    assert(std::abs((var - x_var) / x_var) < 0.01);
+    assert(std::abs((skew - x_skew) / x_skew) < 0.01);
+    assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.03);
+}
+
+void
+test3()
+{
+    typedef std::geometric_distribution<> D;
+    typedef std::minstd_rand G;
+    G g;
+    D d(.25);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
+    {
+        D::result_type v = d(g);
+        assert(d.min() <= v && v <= d.max());
+        u.push_back(v);
+    }
+    double mean = std::accumulate(u.begin(), u.end(),
+                                          double(0)) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
+    {
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
+    }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = (1 - d.p()) / d.p();
+    double x_var = x_mean / d.p();
+    double x_skew = (2 - d.p()) / std::sqrt((1 - d.p()));
+    double x_kurtosis = 6 + sqr(d.p()) / (1 - d.p());
+    assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+    assert(std::abs((var - x_var) / x_var) < 0.01);
+    assert(std::abs((skew - x_skew) / x_skew) < 0.01);
+    assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.02);
+}
+
+void
+test4()
 {
+    typedef std::geometric_distribution<> D;
+    typedef std::mt19937 G;
+    G g;
+    D d(0.5);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
     {
-        typedef std::geometric_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(.03125);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = (1 - d.p()) / d.p();
-        double x_var = x_mean / d.p();
-        double x_skew = (2 - d.p()) / std::sqrt((1 - d.p()));
-        double x_kurtosis = 6 + sqr(d.p()) / (1 - d.p());
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+        D::result_type v = d(g);
+        assert(d.min() <= v && v <= d.max());
+        u.push_back(v);
     }
+    double mean = std::accumulate(u.begin(), u.end(),
+                                          double(0)) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
     {
-        typedef std::geometric_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(0.05);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = (1 - d.p()) / d.p();
-        double x_var = x_mean / d.p();
-        double x_skew = (2 - d.p()) / std::sqrt((1 - d.p()));
-        double x_kurtosis = 6 + sqr(d.p()) / (1 - d.p());
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.03);
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
     }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = (1 - d.p()) / d.p();
+    double x_var = x_mean / d.p();
+    double x_skew = (2 - d.p()) / std::sqrt((1 - d.p()));
+    double x_kurtosis = 6 + sqr(d.p()) / (1 - d.p());
+    assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+    assert(std::abs((var - x_var) / x_var) < 0.01);
+    assert(std::abs((skew - x_skew) / x_skew) < 0.01);
+    assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.02);
+}
+
+void
+test5()
+{
+    typedef std::geometric_distribution<> D;
+    typedef std::mt19937 G;
+    G g;
+    D d(0.75);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
     {
-        typedef std::geometric_distribution<> D;
-        typedef std::minstd_rand G;
-        G g;
-        D d(.25);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = (1 - d.p()) / d.p();
-        double x_var = x_mean / d.p();
-        double x_skew = (2 - d.p()) / std::sqrt((1 - d.p()));
-        double x_kurtosis = 6 + sqr(d.p()) / (1 - d.p());
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.02);
+        D::result_type v = d(g);
+        assert(d.min() <= v && v <= d.max());
+        u.push_back(v);
     }
+    double mean = std::accumulate(u.begin(), u.end(),
+                                          double(0)) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
     {
-        typedef std::geometric_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(0.5);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = (1 - d.p()) / d.p();
-        double x_var = x_mean / d.p();
-        double x_skew = (2 - d.p()) / std::sqrt((1 - d.p()));
-        double x_kurtosis = 6 + sqr(d.p()) / (1 - d.p());
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.02);
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
     }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = (1 - d.p()) / d.p();
+    double x_var = x_mean / d.p();
+    double x_skew = (2 - d.p()) / std::sqrt((1 - d.p()));
+    double x_kurtosis = 6 + sqr(d.p()) / (1 - d.p());
+    assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+    assert(std::abs((var - x_var) / x_var) < 0.01);
+    assert(std::abs((skew - x_skew) / x_skew) < 0.01);
+    assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.02);
+}
+
+void
+test6()
+{
+    typedef std::geometric_distribution<> D;
+    typedef std::mt19937 G;
+    G g;
+    D d(0.96875);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
     {
-        typedef std::geometric_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(0.75);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = (1 - d.p()) / d.p();
-        double x_var = x_mean / d.p();
-        double x_skew = (2 - d.p()) / std::sqrt((1 - d.p()));
-        double x_kurtosis = 6 + sqr(d.p()) / (1 - d.p());
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.02);
+        D::result_type v = d(g);
+        assert(d.min() <= v && v <= d.max());
+        u.push_back(v);
     }
+    double mean = std::accumulate(u.begin(), u.end(),
+                                          double(0)) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
     {
-        typedef std::geometric_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(0.96875);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = (1 - d.p()) / d.p();
-        double x_var = x_mean / d.p();
-        double x_skew = (2 - d.p()) / std::sqrt((1 - d.p()));
-        double x_kurtosis = 6 + sqr(d.p()) / (1 - d.p());
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.02);
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
     }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = (1 - d.p()) / d.p();
+    double x_var = x_mean / d.p();
+    double x_skew = (2 - d.p()) / std::sqrt((1 - d.p()));
+    double x_kurtosis = 6 + sqr(d.p()) / (1 - d.p());
+    assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+    assert(std::abs((var - x_var) / x_var) < 0.01);
+    assert(std::abs((skew - x_skew) / x_skew) < 0.01);
+    assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.02);
+}
+
+int main()
+{
+    test1();
+    test2();
+    test3();
+    test4();
+    test5();
+    test6();
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eval_param.pass.cpp
index 91dea8aa1337..c451f0130904 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eval_param.pass.cpp
@@ -53,10 +53,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -95,10 +95,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -137,10 +137,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eval.pass.cpp
index 853161e9f9b7..929e6e7e6c3b 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eval.pass.cpp
@@ -29,244 +29,268 @@ sqr(T x)
     return x * x;
 }
 
-int main()
+void
+test1()
+{
+    typedef std::negative_binomial_distribution<> D;
+    typedef std::minstd_rand G;
+    G g;
+    D d(5, .25);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
+    {
+        D::result_type v = d(g);
+        assert(d.min() <= v && v <= d.max());
+        u.push_back(v);
+    }
+    double mean = std::accumulate(u.begin(), u.end(),
+                                          double(0)) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
+    {
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
+    }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = d.k() * (1 - d.p()) / d.p();
+    double x_var = x_mean / d.p();
+    double x_skew = (2 - d.p()) / std::sqrt(d.k() * (1 - d.p()));
+    double x_kurtosis = 6. / d.k() + sqr(d.p()) / (d.k() * (1 - d.p()));
+    assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+    assert(std::abs((var - x_var) / x_var) < 0.01);
+    assert(std::abs((skew - x_skew) / x_skew) < 0.01);
+    assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.02);
+}
+
+void
+test2()
+{
+    typedef std::negative_binomial_distribution<> D;
+    typedef std::mt19937 G;
+    G g;
+    D d(30, .03125);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
+    {
+        D::result_type v = d(g);
+        assert(d.min() <= v && v <= d.max());
+        u.push_back(v);
+    }
+    double mean = std::accumulate(u.begin(), u.end(),
+                                          double(0)) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
+    {
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
+    }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = d.k() * (1 - d.p()) / d.p();
+    double x_var = x_mean / d.p();
+    double x_skew = (2 - d.p()) / std::sqrt(d.k() * (1 - d.p()));
+    double x_kurtosis = 6. / d.k() + sqr(d.p()) / (d.k() * (1 - d.p()));
+    assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+    assert(std::abs((var - x_var) / x_var) < 0.01);
+    assert(std::abs((skew - x_skew) / x_skew) < 0.01);
+    assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+}
+
+void
+test3()
+{
+    typedef std::negative_binomial_distribution<> D;
+    typedef std::mt19937 G;
+    G g;
+    D d(40, .25);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
+    {
+        D::result_type v = d(g);
+        assert(d.min() <= v && v <= d.max());
+        u.push_back(v);
+    }
+    double mean = std::accumulate(u.begin(), u.end(),
+                                          double(0)) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
+    {
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
+    }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = d.k() * (1 - d.p()) / d.p();
+    double x_var = x_mean / d.p();
+    double x_skew = (2 - d.p()) / std::sqrt(d.k() * (1 - d.p()));
+    double x_kurtosis = 6. / d.k() + sqr(d.p()) / (d.k() * (1 - d.p()));
+    assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+    assert(std::abs((var - x_var) / x_var) < 0.01);
+    assert(std::abs((skew - x_skew) / x_skew) < 0.01);
+    assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.03);
+}
+
+void
+test4()
 {
+    typedef std::negative_binomial_distribution<> D;
+    typedef std::mt19937 G;
+    G g;
+    D d(40, 1);
+    const int N = 1000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
     {
-        typedef std::negative_binomial_distribution<> D;
-        typedef std::minstd_rand G;
-        G g;
-        D d(5, .25);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = d.k() * (1 - d.p()) / d.p();
-        double x_var = x_mean / d.p();
-        double x_skew = (2 - d.p()) / std::sqrt(d.k() * (1 - d.p()));
-        double x_kurtosis = 6. / d.k() + sqr(d.p()) / (d.k() * (1 - d.p()));
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.02);
+        D::result_type v = d(g);
+        assert(d.min() <= v && v <= d.max());
+        u.push_back(v);
     }
+    double mean = std::accumulate(u.begin(), u.end(),
+                                          double(0)) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
     {
-        typedef std::negative_binomial_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(30, .03125);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = d.k() * (1 - d.p()) / d.p();
-        double x_var = x_mean / d.p();
-        double x_skew = (2 - d.p()) / std::sqrt(d.k() * (1 - d.p()));
-        double x_kurtosis = 6. / d.k() + sqr(d.p()) / (d.k() * (1 - d.p()));
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
     }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = d.k() * (1 - d.p()) / d.p();
+    double x_var = x_mean / d.p();
+    double x_skew = (2 - d.p()) / std::sqrt(d.k() * (1 - d.p()));
+    double x_kurtosis = 6. / d.k() + sqr(d.p()) / (d.k() * (1 - d.p()));
+    assert(mean == x_mean);
+    assert(var == x_var);
+}
+
+void
+test5()
+{
+    typedef std::negative_binomial_distribution<> D;
+    typedef std::mt19937 G;
+    G g;
+    D d(400, 0.5);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
     {
-        typedef std::negative_binomial_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(40, .25);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = d.k() * (1 - d.p()) / d.p();
-        double x_var = x_mean / d.p();
-        double x_skew = (2 - d.p()) / std::sqrt(d.k() * (1 - d.p()));
-        double x_kurtosis = 6. / d.k() + sqr(d.p()) / (d.k() * (1 - d.p()));
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.03);
+        D::result_type v = d(g);
+        assert(d.min() <= v && v <= d.max());
+        u.push_back(v);
     }
+    double mean = std::accumulate(u.begin(), u.end(),
+                                          double(0)) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
     {
-        typedef std::negative_binomial_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(40, 1);
-        const int N = 1000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = d.k() * (1 - d.p()) / d.p();
-        double x_var = x_mean / d.p();
-        double x_skew = (2 - d.p()) / std::sqrt(d.k() * (1 - d.p()));
-        double x_kurtosis = 6. / d.k() + sqr(d.p()) / (d.k() * (1 - d.p()));
-        assert(mean == x_mean);
-        assert(var == x_var);
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
     }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = d.k() * (1 - d.p()) / d.p();
+    double x_var = x_mean / d.p();
+    double x_skew = (2 - d.p()) / std::sqrt(d.k() * (1 - d.p()));
+    double x_kurtosis = 6. / d.k() + sqr(d.p()) / (d.k() * (1 - d.p()));
+    assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+    assert(std::abs((var - x_var) / x_var) < 0.01);
+    assert(std::abs((skew - x_skew) / x_skew) < 0.04);
+    assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.05);
+}
+
+void
+test6()
+{
+    typedef std::negative_binomial_distribution<> D;
+    typedef std::mt19937 G;
+    G g;
+    D d(1, 0.05);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
     {
-        typedef std::negative_binomial_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(400, 0.5);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = d.k() * (1 - d.p()) / d.p();
-        double x_var = x_mean / d.p();
-        double x_skew = (2 - d.p()) / std::sqrt(d.k() * (1 - d.p()));
-        double x_kurtosis = 6. / d.k() + sqr(d.p()) / (d.k() * (1 - d.p()));
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.04);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.05);
+        D::result_type v = d(g);
+        assert(d.min() <= v && v <= d.max());
+        u.push_back(v);
     }
+    double mean = std::accumulate(u.begin(), u.end(),
+                                          double(0)) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
     {
-        typedef std::negative_binomial_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(1, 0.05);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = d.k() * (1 - d.p()) / d.p();
-        double x_var = x_mean / d.p();
-        double x_skew = (2 - d.p()) / std::sqrt(d.k() * (1 - d.p()));
-        double x_kurtosis = 6. / d.k() + sqr(d.p()) / (d.k() * (1 - d.p()));
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.03);
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
     }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = d.k() * (1 - d.p()) / d.p();
+    double x_var = x_mean / d.p();
+    double x_skew = (2 - d.p()) / std::sqrt(d.k() * (1 - d.p()));
+    double x_kurtosis = 6. / d.k() + sqr(d.p()) / (d.k() * (1 - d.p()));
+    assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+    assert(std::abs((var - x_var) / x_var) < 0.01);
+    assert(std::abs((skew - x_skew) / x_skew) < 0.01);
+    assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.03);
+}
+
+int main()
+{
+    test1();
+    test2();
+    test3();
+    test4();
+    test5();
+    test6();
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eval_param.pass.cpp
index f2f2a07879e2..2710061a1a05 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eval_param.pass.cpp
@@ -53,10 +53,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -95,10 +95,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -137,10 +137,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eval.pass.cpp
index 6fbdd93f8ffd..f6bc3c73993c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eval.pass.cpp
@@ -51,10 +51,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -91,10 +91,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -131,10 +131,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eval_param.pass.cpp
index 548848d19f3e..fd52a0488979 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eval_param.pass.cpp
@@ -52,10 +52,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -93,10 +93,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -134,10 +134,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval.pass.cpp
index 9b111cced8a8..2ad6784cd878 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval.pass.cpp
@@ -29,216 +29,236 @@ sqr(T x)
     return x * x;
 }
 
-int main()
+void
+test1()
+{
+    typedef std::lognormal_distribution<> D;
+    typedef D::param_type P;
+    typedef std::mt19937 G;
+    G g;
+    D d(-1./8192, 0.015625);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
+    {
+        D::result_type v = d(g);
+        assert(v > 0);
+        u.push_back(v);
+    }
+    double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
+    {
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
+    }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = std::exp(d.m() + sqr(d.s())/2);
+    double x_var = (std::exp(sqr(d.s())) - 1) * std::exp(2*d.m() + sqr(d.s()));
+    double x_skew = (std::exp(sqr(d.s())) + 2) *
+          std::sqrt((std::exp(sqr(d.s())) - 1));
+    double x_kurtosis = std::exp(4*sqr(d.s())) + 2*std::exp(3*sqr(d.s())) +
+                      3*std::exp(2*sqr(d.s())) - 6;
+    assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+    assert(std::abs((var - x_var) / x_var) < 0.01);
+    assert(std::abs((skew - x_skew) / x_skew) < 0.05);
+    assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.25);
+}
+
+void
+test2()
 {
+    typedef std::lognormal_distribution<> D;
+    typedef D::param_type P;
+    typedef std::mt19937 G;
+    G g;
+    D d(-1./32, 0.25);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
     {
-        typedef std::lognormal_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d(-1./8192, 0.015625);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(v > 0);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = std::exp(d.m() + sqr(d.s())/2);
-        double x_var = (std::exp(sqr(d.s())) - 1) * std::exp(2*d.m() + sqr(d.s()));
-        double x_skew = (std::exp(sqr(d.s())) + 2) *
-              std::sqrt((std::exp(sqr(d.s())) - 1));
-        double x_kurtosis = std::exp(4*sqr(d.s())) + 2*std::exp(3*sqr(d.s())) +
-                          3*std::exp(2*sqr(d.s())) - 6;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.05);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.25);
+        D::result_type v = d(g);
+        assert(v > 0);
+        u.push_back(v);
     }
+    double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
     {
-        typedef std::lognormal_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d(-1./32, 0.25);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(v > 0);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = std::exp(d.m() + sqr(d.s())/2);
-        double x_var = (std::exp(sqr(d.s())) - 1) * std::exp(2*d.m() + sqr(d.s()));
-        double x_skew = (std::exp(sqr(d.s())) + 2) *
-              std::sqrt((std::exp(sqr(d.s())) - 1));
-        double x_kurtosis = std::exp(4*sqr(d.s())) + 2*std::exp(3*sqr(d.s())) +
-                          3*std::exp(2*sqr(d.s())) - 6;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.03);
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
     }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = std::exp(d.m() + sqr(d.s())/2);
+    double x_var = (std::exp(sqr(d.s())) - 1) * std::exp(2*d.m() + sqr(d.s()));
+    double x_skew = (std::exp(sqr(d.s())) + 2) *
+          std::sqrt((std::exp(sqr(d.s())) - 1));
+    double x_kurtosis = std::exp(4*sqr(d.s())) + 2*std::exp(3*sqr(d.s())) +
+                      3*std::exp(2*sqr(d.s())) - 6;
+    assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+    assert(std::abs((var - x_var) / x_var) < 0.01);
+    assert(std::abs((skew - x_skew) / x_skew) < 0.01);
+    assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.03);
+}
+
+void
+test3()
+{
+    typedef std::lognormal_distribution<> D;
+    typedef D::param_type P;
+    typedef std::mt19937 G;
+    G g;
+    D d(-1./8, 0.5);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
     {
-        typedef std::lognormal_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d(-1./8, 0.5);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(v > 0);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = std::exp(d.m() + sqr(d.s())/2);
-        double x_var = (std::exp(sqr(d.s())) - 1) * std::exp(2*d.m() + sqr(d.s()));
-        double x_skew = (std::exp(sqr(d.s())) + 2) *
-              std::sqrt((std::exp(sqr(d.s())) - 1));
-        double x_kurtosis = std::exp(4*sqr(d.s())) + 2*std::exp(3*sqr(d.s())) +
-                          3*std::exp(2*sqr(d.s())) - 6;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.02);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.05);
+        D::result_type v = d(g);
+        assert(v > 0);
+        u.push_back(v);
     }
+    double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
     {
-        typedef std::lognormal_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d;
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(v > 0);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = std::exp(d.m() + sqr(d.s())/2);
-        double x_var = (std::exp(sqr(d.s())) - 1) * std::exp(2*d.m() + sqr(d.s()));
-        double x_skew = (std::exp(sqr(d.s())) + 2) *
-              std::sqrt((std::exp(sqr(d.s())) - 1));
-        double x_kurtosis = std::exp(4*sqr(d.s())) + 2*std::exp(3*sqr(d.s())) +
-                          3*std::exp(2*sqr(d.s())) - 6;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.02);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.08);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.4);
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
     }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = std::exp(d.m() + sqr(d.s())/2);
+    double x_var = (std::exp(sqr(d.s())) - 1) * std::exp(2*d.m() + sqr(d.s()));
+    double x_skew = (std::exp(sqr(d.s())) + 2) *
+          std::sqrt((std::exp(sqr(d.s())) - 1));
+    double x_kurtosis = std::exp(4*sqr(d.s())) + 2*std::exp(3*sqr(d.s())) +
+                      3*std::exp(2*sqr(d.s())) - 6;
+    assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+    assert(std::abs((var - x_var) / x_var) < 0.01);
+    assert(std::abs((skew - x_skew) / x_skew) < 0.02);
+    assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.05);
+}
+
+void
+test4()
+{
+    typedef std::lognormal_distribution<> D;
+    typedef D::param_type P;
+    typedef std::mt19937 G;
+    G g;
+    D d;
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
     {
-        typedef std::lognormal_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d(-0.78125, 1.25);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(v > 0);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = std::exp(d.m() + sqr(d.s())/2);
-        double x_var = (std::exp(sqr(d.s())) - 1) * std::exp(2*d.m() + sqr(d.s()));
-        double x_skew = (std::exp(sqr(d.s())) + 2) *
-              std::sqrt((std::exp(sqr(d.s())) - 1));
-        double x_kurtosis = std::exp(4*sqr(d.s())) + 2*std::exp(3*sqr(d.s())) +
-                          3*std::exp(2*sqr(d.s())) - 6;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.04);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.2);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.7);
+        D::result_type v = d(g);
+        assert(v > 0);
+        u.push_back(v);
     }
+    double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
+    {
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
+    }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = std::exp(d.m() + sqr(d.s())/2);
+    double x_var = (std::exp(sqr(d.s())) - 1) * std::exp(2*d.m() + sqr(d.s()));
+    double x_skew = (std::exp(sqr(d.s())) + 2) *
+          std::sqrt((std::exp(sqr(d.s())) - 1));
+    double x_kurtosis = std::exp(4*sqr(d.s())) + 2*std::exp(3*sqr(d.s())) +
+                      3*std::exp(2*sqr(d.s())) - 6;
+    assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+    assert(std::abs((var - x_var) / x_var) < 0.02);
+    assert(std::abs((skew - x_skew) / x_skew) < 0.08);
+    assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.4);
+}
+
+void
+test5()
+{
+    typedef std::lognormal_distribution<> D;
+    typedef D::param_type P;
+    typedef std::mt19937 G;
+    G g;
+    D d(-0.78125, 1.25);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
+    {
+        D::result_type v = d(g);
+        assert(v > 0);
+        u.push_back(v);
+    }
+    double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
+    {
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
+    }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = std::exp(d.m() + sqr(d.s())/2);
+    double x_var = (std::exp(sqr(d.s())) - 1) * std::exp(2*d.m() + sqr(d.s()));
+    double x_skew = (std::exp(sqr(d.s())) + 2) *
+          std::sqrt((std::exp(sqr(d.s())) - 1));
+    double x_kurtosis = std::exp(4*sqr(d.s())) + 2*std::exp(3*sqr(d.s())) +
+                      3*std::exp(2*sqr(d.s())) - 6;
+    assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+    assert(std::abs((var - x_var) / x_var) < 0.04);
+    assert(std::abs((skew - x_skew) / x_skew) < 0.2);
+    assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.7);
+}
+
+int main()
+{
+    test1();
+    test2();
+    test3();
+    test4();
+    test5();
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval_param.pass.cpp
index 283403ea1a0d..8f397fcab096 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval_param.pass.cpp
@@ -29,222 +29,241 @@ sqr(T x)
     return x * x;
 }
 
-int main()
+void
+test1()
 {
+    typedef std::lognormal_distribution<> D;
+    typedef D::param_type P;
+    typedef std::mt19937 G;
+    G g;
+    D d;
+    P p(-1./8192, 0.015625);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
+    {
+        D::result_type v = d(g, p);
+        assert(v > 0);
+        u.push_back(v);
+    }
+    double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
+    {
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
+    }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = std::exp(p.m() + sqr(p.s())/2);
+    double x_var = (std::exp(sqr(p.s())) - 1) * std::exp(2*p.m() + sqr(p.s()));
+    double x_skew = (std::exp(sqr(p.s())) + 2) *
+          std::sqrt((std::exp(sqr(p.s())) - 1));
+    double x_kurtosis = std::exp(4*sqr(p.s())) + 2*std::exp(3*sqr(p.s())) +
+                      3*std::exp(2*sqr(p.s())) - 6;
+    assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+    assert(std::abs((var - x_var) / x_var) < 0.01);
+    assert(std::abs((skew - x_skew) / x_skew) < 0.05);
+    assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.25);
+}
+
+void
+test2()
+{
+    typedef std::lognormal_distribution<> D;
+    typedef D::param_type P;
+    typedef std::mt19937 G;
+    G g;
+    D d;
+    P p(-1./32, 0.25);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
+    {
+        D::result_type v = d(g, p);
+        assert(v > 0);
+        u.push_back(v);
+    }
+    double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
+    {
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
+    }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = std::exp(p.m() + sqr(p.s())/2);
+    double x_var = (std::exp(sqr(p.s())) - 1) * std::exp(2*p.m() + sqr(p.s()));
+    double x_skew = (std::exp(sqr(p.s())) + 2) *
+          std::sqrt((std::exp(sqr(p.s())) - 1));
+    double x_kurtosis = std::exp(4*sqr(p.s())) + 2*std::exp(3*sqr(p.s())) +
+                      3*std::exp(2*sqr(p.s())) - 6;
+    assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+    assert(std::abs((var - x_var) / x_var) < 0.01);
+    assert(std::abs((skew - x_skew) / x_skew) < 0.01);
+    assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.03);
+}
 
+void
+test3()
+{
+    typedef std::lognormal_distribution<> D;
+    typedef D::param_type P;
+    typedef std::mt19937 G;
+    G g;
+    D d;
+    P p(-1./8, 0.5);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
     {
-        typedef std::lognormal_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d;
-        P p(-1./8192, 0.015625);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g, p);
-            assert(v > 0);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = std::exp(p.m() + sqr(p.s())/2);
-        double x_var = (std::exp(sqr(p.s())) - 1) * std::exp(2*p.m() + sqr(p.s()));
-        double x_skew = (std::exp(sqr(p.s())) + 2) *
-              std::sqrt((std::exp(sqr(p.s())) - 1));
-        double x_kurtosis = std::exp(4*sqr(p.s())) + 2*std::exp(3*sqr(p.s())) +
-                          3*std::exp(2*sqr(p.s())) - 6;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.05);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.25);
+        D::result_type v = d(g, p);
+        assert(v > 0);
+        u.push_back(v);
     }
+    double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
     {
-        typedef std::lognormal_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d;
-        P p(-1./32, 0.25);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g, p);
-            assert(v > 0);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = std::exp(p.m() + sqr(p.s())/2);
-        double x_var = (std::exp(sqr(p.s())) - 1) * std::exp(2*p.m() + sqr(p.s()));
-        double x_skew = (std::exp(sqr(p.s())) + 2) *
-              std::sqrt((std::exp(sqr(p.s())) - 1));
-        double x_kurtosis = std::exp(4*sqr(p.s())) + 2*std::exp(3*sqr(p.s())) +
-                          3*std::exp(2*sqr(p.s())) - 6;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.03);
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
     }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = std::exp(p.m() + sqr(p.s())/2);
+    double x_var = (std::exp(sqr(p.s())) - 1) * std::exp(2*p.m() + sqr(p.s()));
+    double x_skew = (std::exp(sqr(p.s())) + 2) *
+          std::sqrt((std::exp(sqr(p.s())) - 1));
+    double x_kurtosis = std::exp(4*sqr(p.s())) + 2*std::exp(3*sqr(p.s())) +
+                      3*std::exp(2*sqr(p.s())) - 6;
+    assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+    assert(std::abs((var - x_var) / x_var) < 0.01);
+    assert(std::abs((skew - x_skew) / x_skew) < 0.02);
+    assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.05);
+}
+
+void
+test4()
+{
+    typedef std::lognormal_distribution<> D;
+    typedef D::param_type P;
+    typedef std::mt19937 G;
+    G g;
+    D d(3, 4);
+    P p;
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
     {
-        typedef std::lognormal_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d;
-        P p(-1./8, 0.5);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g, p);
-            assert(v > 0);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = std::exp(p.m() + sqr(p.s())/2);
-        double x_var = (std::exp(sqr(p.s())) - 1) * std::exp(2*p.m() + sqr(p.s()));
-        double x_skew = (std::exp(sqr(p.s())) + 2) *
-              std::sqrt((std::exp(sqr(p.s())) - 1));
-        double x_kurtosis = std::exp(4*sqr(p.s())) + 2*std::exp(3*sqr(p.s())) +
-                          3*std::exp(2*sqr(p.s())) - 6;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.02);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.05);
+        D::result_type v = d(g, p);
+        assert(v > 0);
+        u.push_back(v);
     }
+    double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
     {
-        typedef std::lognormal_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d(3, 4);
-        P p;
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g, p);
-            assert(v > 0);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = std::exp(p.m() + sqr(p.s())/2);
-        double x_var = (std::exp(sqr(p.s())) - 1) * std::exp(2*p.m() + sqr(p.s()));
-        double x_skew = (std::exp(sqr(p.s())) + 2) *
-              std::sqrt((std::exp(sqr(p.s())) - 1));
-        double x_kurtosis = std::exp(4*sqr(p.s())) + 2*std::exp(3*sqr(p.s())) +
-                          3*std::exp(2*sqr(p.s())) - 6;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.02);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.08);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.4);
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
     }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = std::exp(p.m() + sqr(p.s())/2);
+    double x_var = (std::exp(sqr(p.s())) - 1) * std::exp(2*p.m() + sqr(p.s()));
+    double x_skew = (std::exp(sqr(p.s())) + 2) *
+          std::sqrt((std::exp(sqr(p.s())) - 1));
+    double x_kurtosis = std::exp(4*sqr(p.s())) + 2*std::exp(3*sqr(p.s())) +
+                      3*std::exp(2*sqr(p.s())) - 6;
+    assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+    assert(std::abs((var - x_var) / x_var) < 0.02);
+    assert(std::abs((skew - x_skew) / x_skew) < 0.08);
+    assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.4);
+}
+
+void
+test5()
+{
+    typedef std::lognormal_distribution<> D;
+    typedef D::param_type P;
+    typedef std::mt19937 G;
+    G g;
+    D d;
+    P p(-0.78125, 1.25);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
     {
-        typedef std::lognormal_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d;
-        P p(-0.78125, 1.25);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g, p);
-            assert(v > 0);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = std::exp(p.m() + sqr(p.s())/2);
-        double x_var = (std::exp(sqr(p.s())) - 1) * std::exp(2*p.m() + sqr(p.s()));
-        double x_skew = (std::exp(sqr(p.s())) + 2) *
-              std::sqrt((std::exp(sqr(p.s())) - 1));
-        double x_kurtosis = std::exp(4*sqr(p.s())) + 2*std::exp(3*sqr(p.s())) +
-                          3*std::exp(2*sqr(p.s())) - 6;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.04);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.2);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.7);
+        D::result_type v = d(g, p);
+        assert(v > 0);
+        u.push_back(v);
     }
+    double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
+    {
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
+    }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = std::exp(p.m() + sqr(p.s())/2);
+    double x_var = (std::exp(sqr(p.s())) - 1) * std::exp(2*p.m() + sqr(p.s()));
+    double x_skew = (std::exp(sqr(p.s())) + 2) *
+          std::sqrt((std::exp(sqr(p.s())) - 1));
+    double x_kurtosis = std::exp(4*sqr(p.s())) + 2*std::exp(3*sqr(p.s())) +
+                      3*std::exp(2*sqr(p.s())) - 6;
+    assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+    assert(std::abs((var - x_var) / x_var) < 0.04);
+    assert(std::abs((skew - x_skew) / x_skew) < 0.2);
+    assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.7);
+}
+
+int main()
+{
+    test1();
+    test2();
+    test3();
+    test4();
+    test5();
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eval.pass.cpp
index 95d0272dbc32..69f786397711 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eval.pass.cpp
@@ -47,10 +47,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eval_param.pass.cpp
index 20c3a44f13e1..af9c547cb7f9 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eval_param.pass.cpp
@@ -48,10 +48,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval.pass.cpp
index ef6b37e9f9cc..9210e8a8d350 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval.pass.cpp
@@ -47,10 +47,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -83,10 +83,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -119,10 +119,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval_param.pass.cpp
index 70bc29e3ad13..93053f0a36b7 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval_param.pass.cpp
@@ -48,10 +48,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -85,10 +85,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -122,10 +122,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eval.pass.cpp
index b2fe52676e7e..42965b0e6ab2 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eval.pass.cpp
@@ -51,10 +51,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -91,10 +91,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -131,10 +131,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eval_param.pass.cpp
index 9879e63a33e9..e7de18fdb434 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eval_param.pass.cpp
@@ -52,10 +52,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval.pass.cpp
index 6390acef8941..3f1b331889e5 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval.pass.cpp
@@ -29,162 +29,178 @@ sqr(T x)
     return x * x;
 }
 
-int main()
+void
+test1()
+{
+    typedef std::extreme_value_distribution<> D;
+    typedef D::param_type P;
+    typedef std::mt19937 G;
+    G g;
+    D d(0.5, 2);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
+    {
+        D::result_type v = d(g);
+        u.push_back(v);
+    }
+    double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
+    {
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
+    }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = d.a() + d.b() * 0.577215665;
+    double x_var = sqr(d.b()) * 1.644934067;
+    double x_skew = 1.139547;
+    double x_kurtosis = 12./5;
+    assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+    assert(std::abs((var - x_var) / x_var) < 0.01);
+    assert(std::abs((skew - x_skew) / x_skew) < 0.01);
+    assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+}
+
+void
+test2()
+{
+    typedef std::extreme_value_distribution<> D;
+    typedef D::param_type P;
+    typedef std::mt19937 G;
+    G g;
+    D d(1, 2);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
+    {
+        D::result_type v = d(g);
+        u.push_back(v);
+    }
+    double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
+    {
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
+    }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = d.a() + d.b() * 0.577215665;
+    double x_var = sqr(d.b()) * 1.644934067;
+    double x_skew = 1.139547;
+    double x_kurtosis = 12./5;
+    assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+    assert(std::abs((var - x_var) / x_var) < 0.01);
+    assert(std::abs((skew - x_skew) / x_skew) < 0.01);
+    assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+}
+
+void
+test3()
 {
+    typedef std::extreme_value_distribution<> D;
+    typedef D::param_type P;
+    typedef std::mt19937 G;
+    G g;
+    D d(1.5, 3);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
     {
-        typedef std::extreme_value_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d(0.5, 2);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = d.a() + d.b() * 0.577215665;
-        double x_var = sqr(d.b()) * 1.644934067;
-        double x_skew = 1.139547;
-        double x_kurtosis = 12./5;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+        D::result_type v = d(g);
+        u.push_back(v);
     }
+    double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
     {
-        typedef std::extreme_value_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d(1, 2);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = d.a() + d.b() * 0.577215665;
-        double x_var = sqr(d.b()) * 1.644934067;
-        double x_skew = 1.139547;
-        double x_kurtosis = 12./5;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
     }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = d.a() + d.b() * 0.577215665;
+    double x_var = sqr(d.b()) * 1.644934067;
+    double x_skew = 1.139547;
+    double x_kurtosis = 12./5;
+    assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+    assert(std::abs((var - x_var) / x_var) < 0.01);
+    assert(std::abs((skew - x_skew) / x_skew) < 0.01);
+    assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+}
+
+void
+test4()
+{
+    typedef std::extreme_value_distribution<> D;
+    typedef D::param_type P;
+    typedef std::mt19937 G;
+    G g;
+    D d(3, 4);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
     {
-        typedef std::extreme_value_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d(1.5, 3);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = d.a() + d.b() * 0.577215665;
-        double x_var = sqr(d.b()) * 1.644934067;
-        double x_skew = 1.139547;
-        double x_kurtosis = 12./5;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+        D::result_type v = d(g);
+        u.push_back(v);
     }
+    double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
     {
-        typedef std::extreme_value_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d(3, 4);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = d.a() + d.b() * 0.577215665;
-        double x_var = sqr(d.b()) * 1.644934067;
-        double x_skew = 1.139547;
-        double x_kurtosis = 12./5;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
     }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = d.a() + d.b() * 0.577215665;
+    double x_var = sqr(d.b()) * 1.644934067;
+    double x_skew = 1.139547;
+    double x_kurtosis = 12./5;
+    assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+    assert(std::abs((var - x_var) / x_var) < 0.01);
+    assert(std::abs((skew - x_skew) / x_skew) < 0.01);
+    assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+}
+
+int main()
+{
+    test1();
+    test2();
+    test3();
+    test4();
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval_param.pass.cpp
index 6152cce8f4f8..21bf774228f8 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval_param.pass.cpp
@@ -29,166 +29,182 @@ sqr(T x)
     return x * x;
 }
 
-int main()
+void
+test1()
+{
+    typedef std::extreme_value_distribution<> D;
+    typedef D::param_type P;
+    typedef std::mt19937 G;
+    G g;
+    D d(-0.5, 1);
+    P p(0.5, 2);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
+    {
+        D::result_type v = d(g, p);
+        u.push_back(v);
+    }
+    double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
+    {
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
+    }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = p.a() + p.b() * 0.577215665;
+    double x_var = sqr(p.b()) * 1.644934067;
+    double x_skew = 1.139547;
+    double x_kurtosis = 12./5;
+    assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+    assert(std::abs((var - x_var) / x_var) < 0.01);
+    assert(std::abs((skew - x_skew) / x_skew) < 0.01);
+    assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+}
+
+void
+test2()
+{
+    typedef std::extreme_value_distribution<> D;
+    typedef D::param_type P;
+    typedef std::mt19937 G;
+    G g;
+    D d(-0.5, 1);
+    P p(1, 2);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
+    {
+        D::result_type v = d(g, p);
+        u.push_back(v);
+    }
+    double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
+    {
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
+    }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = p.a() + p.b() * 0.577215665;
+    double x_var = sqr(p.b()) * 1.644934067;
+    double x_skew = 1.139547;
+    double x_kurtosis = 12./5;
+    assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+    assert(std::abs((var - x_var) / x_var) < 0.01);
+    assert(std::abs((skew - x_skew) / x_skew) < 0.01);
+    assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+}
+
+void
+test3()
 {
+    typedef std::extreme_value_distribution<> D;
+    typedef D::param_type P;
+    typedef std::mt19937 G;
+    G g;
+    D d(-0.5, 1);
+    P p(1.5, 3);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
     {
-        typedef std::extreme_value_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d(-0.5, 1);
-        P p(0.5, 2);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g, p);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = p.a() + p.b() * 0.577215665;
-        double x_var = sqr(p.b()) * 1.644934067;
-        double x_skew = 1.139547;
-        double x_kurtosis = 12./5;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+        D::result_type v = d(g, p);
+        u.push_back(v);
     }
+    double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
     {
-        typedef std::extreme_value_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d(-0.5, 1);
-        P p(1, 2);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g, p);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = p.a() + p.b() * 0.577215665;
-        double x_var = sqr(p.b()) * 1.644934067;
-        double x_skew = 1.139547;
-        double x_kurtosis = 12./5;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
     }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = p.a() + p.b() * 0.577215665;
+    double x_var = sqr(p.b()) * 1.644934067;
+    double x_skew = 1.139547;
+    double x_kurtosis = 12./5;
+    assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+    assert(std::abs((var - x_var) / x_var) < 0.01);
+    assert(std::abs((skew - x_skew) / x_skew) < 0.01);
+    assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+}
+
+void
+test4()
+{
+    typedef std::extreme_value_distribution<> D;
+    typedef D::param_type P;
+    typedef std::mt19937 G;
+    G g;
+    D d(-0.5, 1);
+    P p(3, 4);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
     {
-        typedef std::extreme_value_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d(-0.5, 1);
-        P p(1.5, 3);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g, p);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = p.a() + p.b() * 0.577215665;
-        double x_var = sqr(p.b()) * 1.644934067;
-        double x_skew = 1.139547;
-        double x_kurtosis = 12./5;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+        D::result_type v = d(g, p);
+        u.push_back(v);
     }
+    double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
+    double var = 0;
+    double skew = 0;
+    double kurtosis = 0;
+    for (int i = 0; i < u.size(); ++i)
     {
-        typedef std::extreme_value_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d(-0.5, 1);
-        P p(3, 4);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g, p);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
-            var += d2;
-            skew += d * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = p.a() + p.b() * 0.577215665;
-        double x_var = sqr(p.b()) * 1.644934067;
-        double x_skew = 1.139547;
-        double x_kurtosis = 12./5;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+        double dbl = (u[i] - mean);
+        double d2 = sqr(dbl);
+        var += d2;
+        skew += dbl * d2;
+        kurtosis += d2 * d2;
     }
+    var /= u.size();
+    double dev = std::sqrt(var);
+    skew /= u.size() * dev * var;
+    kurtosis /= u.size() * var * var;
+    kurtosis -= 3;
+    double x_mean = p.a() + p.b() * 0.577215665;
+    double x_var = sqr(p.b()) * 1.644934067;
+    double x_skew = 1.139547;
+    double x_kurtosis = 12./5;
+    assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+    assert(std::abs((var - x_var) / x_var) < 0.01);
+    assert(std::abs((skew - x_skew) / x_skew) < 0.01);
+    assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+}
+
+int main()
+{
+    test1();
+    test2();
+    test3();
+    test4();
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval.pass.cpp
index 7c26cc8a1c47..7c23630ed1e1 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval.pass.cpp
@@ -51,10 +51,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -91,10 +91,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -131,10 +131,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval_param.pass.cpp
index 8ed39df819d7..54a89b6b3f40 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval_param.pass.cpp
@@ -52,10 +52,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -93,10 +93,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -134,10 +134,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eval.pass.cpp
index f5598978bf0a..a475624a58a8 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eval.pass.cpp
@@ -50,10 +50,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -89,10 +89,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -128,10 +128,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eval_param.pass.cpp
index c3bbdeb0ed6c..d24fbd9f9cf5 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eval_param.pass.cpp
@@ -52,10 +52,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -93,10 +93,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -134,10 +134,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eval.pass.cpp
index e414932dc870..cfec8c0d81e1 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eval.pass.cpp
@@ -51,10 +51,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -95,10 +95,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -139,10 +139,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eval_param.pass.cpp
index 6da705eb26c7..a19654dbd575 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eval_param.pass.cpp
@@ -52,10 +52,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -97,10 +97,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -142,10 +142,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval.pass.cpp
index 5d14b3612b2e..3111912ec29c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval.pass.cpp
@@ -20,6 +20,7 @@
 #include <vector>
 #include <iterator>
 #include <numeric>
+#include <algorithm>   // for sort
 #include <cassert>
 
 template <class T>
@@ -30,666 +31,710 @@ sqr(T x)
     return x*x;
 }
 
-int main()
+void
+test1()
 {
+    typedef std::piecewise_constant_distribution<> D;
+    typedef std::mt19937_64 G;
+    G g;
+    double b[] = {10, 14, 16, 17};
+    double p[] = {25, 62.5, 12.5};
+    const size_t Np = sizeof(p) / sizeof(p[0]);
+    D d(b, b+Np+1, p);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
     {
-        typedef std::piecewise_constant_distribution<> D;
-        typedef std::mt19937_64 G;
-        G g;
-        double b[] = {10, 14, 16, 17};
-        double p[] = {25, 62.5, 12.5};
-        const size_t Np = sizeof(p) / sizeof(p[0]);
-        D d(b, b+Np+1, p);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v < d.max());
-            u.push_back(v);
-        }
-        std::vector<double> prob(std::begin(p), std::end(p));
-        double s = std::accumulate(prob.begin(), prob.end(), 0.0);
-        for (int i = 0; i < prob.size(); ++i)
-            prob[i] /= s;
-        std::sort(u.begin(), u.end());
-        for (int i = 0; i < Np; ++i)
+        D::result_type v = d(g);
+        assert(d.min() <= v && v < d.max());
+        u.push_back(v);
+    }
+    std::vector<double> prob(std::begin(p), std::end(p));
+    double s = std::accumulate(prob.begin(), prob.end(), 0.0);
+    for (int i = 0; i < prob.size(); ++i)
+        prob[i] /= s;
+    std::sort(u.begin(), u.end());
+    for (int i = 0; i < Np; ++i)
+    {
+        typedef std::vector<D::result_type>::iterator I;
+        I lb = std::lower_bound(u.begin(), u.end(), b[i]);
+        I ub = std::lower_bound(u.begin(), u.end(), b[i+1]);
+        const size_t Ni = ub - lb;
+        if (prob[i] == 0)
+            assert(Ni == 0);
+        else
         {
-            typedef std::vector<D::result_type>::iterator I;
-            I lb = std::lower_bound(u.begin(), u.end(), b[i]);
-            I ub = std::lower_bound(u.begin(), u.end(), b[i+1]);
-            const size_t Ni = ub - lb;
-            if (prob[i] == 0)
-                assert(Ni == 0);
-            else
+            assert(std::abs((double)Ni/N - prob[i]) / prob[i] < .01);
+            double mean = std::accumulate(lb, ub, 0.0) / Ni;
+            double var = 0;
+            double skew = 0;
+            double kurtosis = 0;
+            for (I j = lb; j != ub; ++j)
             {
-                assert(std::abs((double)Ni/N - prob[i]) / prob[i] < .01);
-                double mean = std::accumulate(lb, ub, 0.0) / Ni;
-                double var = 0;
-                double skew = 0;
-                double kurtosis = 0;
-                for (I j = lb; j != ub; ++j)
-                {
-                    double d = (*j - mean);
-                    double d2 = sqr(d);
-                    var += d2;
-                    skew += d * d2;
-                    kurtosis += d2 * d2;
-                }
-                var /= Ni;
-                double dev = std::sqrt(var);
-                skew /= Ni * dev * var;
-                kurtosis /= Ni * var * var;
-                kurtosis -= 3;
-                double x_mean = (b[i+1] + b[i]) / 2;
-                double x_var = sqr(b[i+1] - b[i]) / 12;
-                double x_skew = 0;
-                double x_kurtosis = -6./5;
-                assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-                assert(std::abs((var - x_var) / x_var) < 0.01);
-                assert(std::abs(skew - x_skew) < 0.01);
-                assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+                double dbl = (*j - mean);
+                double d2 = sqr(dbl);
+                var += d2;
+                skew += dbl * d2;
+                kurtosis += d2 * d2;
             }
+            var /= Ni;
+            double dev = std::sqrt(var);
+            skew /= Ni * dev * var;
+            kurtosis /= Ni * var * var;
+            kurtosis -= 3;
+            double x_mean = (b[i+1] + b[i]) / 2;
+            double x_var = sqr(b[i+1] - b[i]) / 12;
+            double x_skew = 0;
+            double x_kurtosis = -6./5;
+            assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+            assert(std::abs((var - x_var) / x_var) < 0.01);
+            assert(std::abs(skew - x_skew) < 0.01);
+            assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
         }
     }
+}
+
+void
+test2()
+{
+    typedef std::piecewise_constant_distribution<> D;
+    typedef std::mt19937_64 G;
+    G g;
+    double b[] = {10, 14, 16, 17};
+    double p[] = {0, 62.5, 12.5};
+    const size_t Np = sizeof(p) / sizeof(p[0]);
+    D d(b, b+Np+1, p);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
     {
-        typedef std::piecewise_constant_distribution<> D;
-        typedef std::mt19937_64 G;
-        G g;
-        double b[] = {10, 14, 16, 17};
-        double p[] = {0, 62.5, 12.5};
-        const size_t Np = sizeof(p) / sizeof(p[0]);
-        D d(b, b+Np+1, p);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v < d.max());
-            u.push_back(v);
-        }
-        std::vector<double> prob(std::begin(p), std::end(p));
-        double s = std::accumulate(prob.begin(), prob.end(), 0.0);
-        for (int i = 0; i < prob.size(); ++i)
-            prob[i] /= s;
-        std::sort(u.begin(), u.end());
-        for (int i = 0; i < Np; ++i)
+        D::result_type v = d(g);
+        assert(d.min() <= v && v < d.max());
+        u.push_back(v);
+    }
+    std::vector<double> prob(std::begin(p), std::end(p));
+    double s = std::accumulate(prob.begin(), prob.end(), 0.0);
+    for (int i = 0; i < prob.size(); ++i)
+        prob[i] /= s;
+    std::sort(u.begin(), u.end());
+    for (int i = 0; i < Np; ++i)
+    {
+        typedef std::vector<D::result_type>::iterator I;
+        I lb = std::lower_bound(u.begin(), u.end(), b[i]);
+        I ub = std::lower_bound(u.begin(), u.end(), b[i+1]);
+        const size_t Ni = ub - lb;
+        if (prob[i] == 0)
+            assert(Ni == 0);
+        else
         {
-            typedef std::vector<D::result_type>::iterator I;
-            I lb = std::lower_bound(u.begin(), u.end(), b[i]);
-            I ub = std::lower_bound(u.begin(), u.end(), b[i+1]);
-            const size_t Ni = ub - lb;
-            if (prob[i] == 0)
-                assert(Ni == 0);
-            else
+            assert(std::abs((double)Ni/N - prob[i]) / prob[i] < .01);
+            double mean = std::accumulate(lb, ub, 0.0) / Ni;
+            double var = 0;
+            double skew = 0;
+            double kurtosis = 0;
+            for (I j = lb; j != ub; ++j)
             {
-                assert(std::abs((double)Ni/N - prob[i]) / prob[i] < .01);
-                double mean = std::accumulate(lb, ub, 0.0) / Ni;
-                double var = 0;
-                double skew = 0;
-                double kurtosis = 0;
-                for (I j = lb; j != ub; ++j)
-                {
-                    double d = (*j - mean);
-                    double d2 = sqr(d);
-                    var += d2;
-                    skew += d * d2;
-                    kurtosis += d2 * d2;
-                }
-                var /= Ni;
-                double dev = std::sqrt(var);
-                skew /= Ni * dev * var;
-                kurtosis /= Ni * var * var;
-                kurtosis -= 3;
-                double x_mean = (b[i+1] + b[i]) / 2;
-                double x_var = sqr(b[i+1] - b[i]) / 12;
-                double x_skew = 0;
-                double x_kurtosis = -6./5;
-                assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-                assert(std::abs((var - x_var) / x_var) < 0.01);
-                assert(std::abs(skew - x_skew) < 0.01);
-                assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+                double dbl = (*j - mean);
+                double d2 = sqr(dbl);
+                var += d2;
+                skew += dbl * d2;
+                kurtosis += d2 * d2;
             }
+            var /= Ni;
+            double dev = std::sqrt(var);
+            skew /= Ni * dev * var;
+            kurtosis /= Ni * var * var;
+            kurtosis -= 3;
+            double x_mean = (b[i+1] + b[i]) / 2;
+            double x_var = sqr(b[i+1] - b[i]) / 12;
+            double x_skew = 0;
+            double x_kurtosis = -6./5;
+            assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+            assert(std::abs((var - x_var) / x_var) < 0.01);
+            assert(std::abs(skew - x_skew) < 0.01);
+            assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
         }
     }
+}
+
+void
+test3()
+{
+    typedef std::piecewise_constant_distribution<> D;
+    typedef std::mt19937_64 G;
+    G g;
+    double b[] = {10, 14, 16, 17};
+    double p[] = {25, 0, 12.5};
+    const size_t Np = sizeof(p) / sizeof(p[0]);
+    D d(b, b+Np+1, p);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
+    {
+        D::result_type v = d(g);
+        assert(d.min() <= v && v < d.max());
+        u.push_back(v);
+    }
+    std::vector<double> prob(std::begin(p), std::end(p));
+    double s = std::accumulate(prob.begin(), prob.end(), 0.0);
+    for (int i = 0; i < prob.size(); ++i)
+        prob[i] /= s;
+    std::sort(u.begin(), u.end());
+    for (int i = 0; i < Np; ++i)
     {
-        typedef std::piecewise_constant_distribution<> D;
-        typedef std::mt19937_64 G;
-        G g;
-        double b[] = {10, 14, 16, 17};
-        double p[] = {25, 0, 12.5};
-        const size_t Np = sizeof(p) / sizeof(p[0]);
-        D d(b, b+Np+1, p);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
+        typedef std::vector<D::result_type>::iterator I;
+        I lb = std::lower_bound(u.begin(), u.end(), b[i]);
+        I ub = std::lower_bound(u.begin(), u.end(), b[i+1]);
+        const size_t Ni = ub - lb;
+        if (prob[i] == 0)
+            assert(Ni == 0);
+        else
         {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v < d.max());
-            u.push_back(v);
-        }
-        std::vector<double> prob(std::begin(p), std::end(p));
-        double s = std::accumulate(prob.begin(), prob.end(), 0.0);
-        for (int i = 0; i < prob.size(); ++i)
-            prob[i] /= s;
-        std::sort(u.begin(), u.end());
-        for (int i = 0; i < Np; ++i)
-        {
-            typedef std::vector<D::result_type>::iterator I;
-            I lb = std::lower_bound(u.begin(), u.end(), b[i]);
-            I ub = std::lower_bound(u.begin(), u.end(), b[i+1]);
-            const size_t Ni = ub - lb;
-            if (prob[i] == 0)
-                assert(Ni == 0);
-            else
+            assert(std::abs((double)Ni/N - prob[i]) / prob[i] < .01);
+            double mean = std::accumulate(lb, ub, 0.0) / Ni;
+            double var = 0;
+            double skew = 0;
+            double kurtosis = 0;
+            for (I j = lb; j != ub; ++j)
             {
-                assert(std::abs((double)Ni/N - prob[i]) / prob[i] < .01);
-                double mean = std::accumulate(lb, ub, 0.0) / Ni;
-                double var = 0;
-                double skew = 0;
-                double kurtosis = 0;
-                for (I j = lb; j != ub; ++j)
-                {
-                    double d = (*j - mean);
-                    double d2 = sqr(d);
-                    var += d2;
-                    skew += d * d2;
-                    kurtosis += d2 * d2;
-                }
-                var /= Ni;
-                double dev = std::sqrt(var);
-                skew /= Ni * dev * var;
-                kurtosis /= Ni * var * var;
-                kurtosis -= 3;
-                double x_mean = (b[i+1] + b[i]) / 2;
-                double x_var = sqr(b[i+1] - b[i]) / 12;
-                double x_skew = 0;
-                double x_kurtosis = -6./5;
-                assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-                assert(std::abs((var - x_var) / x_var) < 0.01);
-                assert(std::abs(skew - x_skew) < 0.01);
-                assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+                double dbl = (*j - mean);
+                double d2 = sqr(dbl);
+                var += d2;
+                skew += dbl * d2;
+                kurtosis += d2 * d2;
             }
+            var /= Ni;
+            double dev = std::sqrt(var);
+            skew /= Ni * dev * var;
+            kurtosis /= Ni * var * var;
+            kurtosis -= 3;
+            double x_mean = (b[i+1] + b[i]) / 2;
+            double x_var = sqr(b[i+1] - b[i]) / 12;
+            double x_skew = 0;
+            double x_kurtosis = -6./5;
+            assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+            assert(std::abs((var - x_var) / x_var) < 0.01);
+            assert(std::abs(skew - x_skew) < 0.01);
+            assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
         }
     }
+}
+
+void
+test4()
+{
+    typedef std::piecewise_constant_distribution<> D;
+    typedef std::mt19937_64 G;
+    G g;
+    double b[] = {10, 14, 16, 17};
+    double p[] = {25, 62.5, 0};
+    const size_t Np = sizeof(p) / sizeof(p[0]);
+    D d(b, b+Np+1, p);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
+    {
+        D::result_type v = d(g);
+        assert(d.min() <= v && v < d.max());
+        u.push_back(v);
+    }
+    std::vector<double> prob(std::begin(p), std::end(p));
+    double s = std::accumulate(prob.begin(), prob.end(), 0.0);
+    for (int i = 0; i < prob.size(); ++i)
+        prob[i] /= s;
+    std::sort(u.begin(), u.end());
+    for (int i = 0; i < Np; ++i)
     {
-        typedef std::piecewise_constant_distribution<> D;
-        typedef std::mt19937_64 G;
-        G g;
-        double b[] = {10, 14, 16, 17};
-        double p[] = {25, 62.5, 0};
-        const size_t Np = sizeof(p) / sizeof(p[0]);
-        D d(b, b+Np+1, p);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v < d.max());
-            u.push_back(v);
-        }
-        std::vector<double> prob(std::begin(p), std::end(p));
-        double s = std::accumulate(prob.begin(), prob.end(), 0.0);
-        for (int i = 0; i < prob.size(); ++i)
-            prob[i] /= s;
-        std::sort(u.begin(), u.end());
-        for (int i = 0; i < Np; ++i)
+        typedef std::vector<D::result_type>::iterator I;
+        I lb = std::lower_bound(u.begin(), u.end(), b[i]);
+        I ub = std::lower_bound(u.begin(), u.end(), b[i+1]);
+        const size_t Ni = ub - lb;
+        if (prob[i] == 0)
+            assert(Ni == 0);
+        else
         {
-            typedef std::vector<D::result_type>::iterator I;
-            I lb = std::lower_bound(u.begin(), u.end(), b[i]);
-            I ub = std::lower_bound(u.begin(), u.end(), b[i+1]);
-            const size_t Ni = ub - lb;
-            if (prob[i] == 0)
-                assert(Ni == 0);
-            else
+            assert(std::abs((double)Ni/N - prob[i]) / prob[i] < .01);
+            double mean = std::accumulate(lb, ub, 0.0) / Ni;
+            double var = 0;
+            double skew = 0;
+            double kurtosis = 0;
+            for (I j = lb; j != ub; ++j)
             {
-                assert(std::abs((double)Ni/N - prob[i]) / prob[i] < .01);
-                double mean = std::accumulate(lb, ub, 0.0) / Ni;
-                double var = 0;
-                double skew = 0;
-                double kurtosis = 0;
-                for (I j = lb; j != ub; ++j)
-                {
-                    double d = (*j - mean);
-                    double d2 = sqr(d);
-                    var += d2;
-                    skew += d * d2;
-                    kurtosis += d2 * d2;
-                }
-                var /= Ni;
-                double dev = std::sqrt(var);
-                skew /= Ni * dev * var;
-                kurtosis /= Ni * var * var;
-                kurtosis -= 3;
-                double x_mean = (b[i+1] + b[i]) / 2;
-                double x_var = sqr(b[i+1] - b[i]) / 12;
-                double x_skew = 0;
-                double x_kurtosis = -6./5;
-                assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-                assert(std::abs((var - x_var) / x_var) < 0.01);
-                assert(std::abs(skew - x_skew) < 0.01);
-                assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+                double dbl = (*j - mean);
+                double d2 = sqr(dbl);
+                var += d2;
+                skew += dbl * d2;
+                kurtosis += d2 * d2;
             }
+            var /= Ni;
+            double dev = std::sqrt(var);
+            skew /= Ni * dev * var;
+            kurtosis /= Ni * var * var;
+            kurtosis -= 3;
+            double x_mean = (b[i+1] + b[i]) / 2;
+            double x_var = sqr(b[i+1] - b[i]) / 12;
+            double x_skew = 0;
+            double x_kurtosis = -6./5;
+            assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+            assert(std::abs((var - x_var) / x_var) < 0.01);
+            assert(std::abs(skew - x_skew) < 0.01);
+            assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
         }
     }
+}
+
+void
+test5()
+{
+    typedef std::piecewise_constant_distribution<> D;
+    typedef std::mt19937_64 G;
+    G g;
+    double b[] = {10, 14, 16, 17};
+    double p[] = {25, 0, 0};
+    const size_t Np = sizeof(p) / sizeof(p[0]);
+    D d(b, b+Np+1, p);
+    const int N = 100000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
     {
-        typedef std::piecewise_constant_distribution<> D;
-        typedef std::mt19937_64 G;
-        G g;
-        double b[] = {10, 14, 16, 17};
-        double p[] = {25, 0, 0};
-        const size_t Np = sizeof(p) / sizeof(p[0]);
-        D d(b, b+Np+1, p);
-        const int N = 100000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v < d.max());
-            u.push_back(v);
-        }
-        std::vector<double> prob(std::begin(p), std::end(p));
-        double s = std::accumulate(prob.begin(), prob.end(), 0.0);
-        for (int i = 0; i < prob.size(); ++i)
-            prob[i] /= s;
-        std::sort(u.begin(), u.end());
-        for (int i = 0; i < Np; ++i)
+        D::result_type v = d(g);
+        assert(d.min() <= v && v < d.max());
+        u.push_back(v);
+    }
+    std::vector<double> prob(std::begin(p), std::end(p));
+    double s = std::accumulate(prob.begin(), prob.end(), 0.0);
+    for (int i = 0; i < prob.size(); ++i)
+        prob[i] /= s;
+    std::sort(u.begin(), u.end());
+    for (int i = 0; i < Np; ++i)
+    {
+        typedef std::vector<D::result_type>::iterator I;
+        I lb = std::lower_bound(u.begin(), u.end(), b[i]);
+        I ub = std::lower_bound(u.begin(), u.end(), b[i+1]);
+        const size_t Ni = ub - lb;
+        if (prob[i] == 0)
+            assert(Ni == 0);
+        else
         {
-            typedef std::vector<D::result_type>::iterator I;
-            I lb = std::lower_bound(u.begin(), u.end(), b[i]);
-            I ub = std::lower_bound(u.begin(), u.end(), b[i+1]);
-            const size_t Ni = ub - lb;
-            if (prob[i] == 0)
-                assert(Ni == 0);
-            else
+            assert(std::abs((double)Ni/N - prob[i]) / prob[i] < .01);
+            double mean = std::accumulate(lb, ub, 0.0) / Ni;
+            double var = 0;
+            double skew = 0;
+            double kurtosis = 0;
+            for (I j = lb; j != ub; ++j)
             {
-                assert(std::abs((double)Ni/N - prob[i]) / prob[i] < .01);
-                double mean = std::accumulate(lb, ub, 0.0) / Ni;
-                double var = 0;
-                double skew = 0;
-                double kurtosis = 0;
-                for (I j = lb; j != ub; ++j)
-                {
-                    double d = (*j - mean);
-                    double d2 = sqr(d);
-                    var += d2;
-                    skew += d * d2;
-                    kurtosis += d2 * d2;
-                }
-                var /= Ni;
-                double dev = std::sqrt(var);
-                skew /= Ni * dev * var;
-                kurtosis /= Ni * var * var;
-                kurtosis -= 3;
-                double x_mean = (b[i+1] + b[i]) / 2;
-                double x_var = sqr(b[i+1] - b[i]) / 12;
-                double x_skew = 0;
-                double x_kurtosis = -6./5;
-                assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-                assert(std::abs((var - x_var) / x_var) < 0.01);
-                assert(std::abs(skew - x_skew) < 0.01);
-                assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+                double dbl = (*j - mean);
+                double d2 = sqr(dbl);
+                var += d2;
+                skew += dbl * d2;
+                kurtosis += d2 * d2;
             }
+            var /= Ni;
+            double dev = std::sqrt(var);
+            skew /= Ni * dev * var;
+            kurtosis /= Ni * var * var;
+            kurtosis -= 3;
+            double x_mean = (b[i+1] + b[i]) / 2;
+            double x_var = sqr(b[i+1] - b[i]) / 12;
+            double x_skew = 0;
+            double x_kurtosis = -6./5;
+            assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+            assert(std::abs((var - x_var) / x_var) < 0.01);
+            assert(std::abs(skew - x_skew) < 0.01);
+            assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
         }
     }
+}
+
+void
+test6()
+{
+    typedef std::piecewise_constant_distribution<> D;
+    typedef std::mt19937_64 G;
+    G g;
+    double b[] = {10, 14, 16, 17};
+    double p[] = {0, 25, 0};
+    const size_t Np = sizeof(p) / sizeof(p[0]);
+    D d(b, b+Np+1, p);
+    const int N = 100000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
+    {
+        D::result_type v = d(g);
+        assert(d.min() <= v && v < d.max());
+        u.push_back(v);
+    }
+    std::vector<double> prob(std::begin(p), std::end(p));
+    double s = std::accumulate(prob.begin(), prob.end(), 0.0);
+    for (int i = 0; i < prob.size(); ++i)
+        prob[i] /= s;
+    std::sort(u.begin(), u.end());
+    for (int i = 0; i < Np; ++i)
     {
-        typedef std::piecewise_constant_distribution<> D;
-        typedef std::mt19937_64 G;
-        G g;
-        double b[] = {10, 14, 16, 17};
-        double p[] = {0, 25, 0};
-        const size_t Np = sizeof(p) / sizeof(p[0]);
-        D d(b, b+Np+1, p);
-        const int N = 100000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v < d.max());
-            u.push_back(v);
-        }
-        std::vector<double> prob(std::begin(p), std::end(p));
-        double s = std::accumulate(prob.begin(), prob.end(), 0.0);
-        for (int i = 0; i < prob.size(); ++i)
-            prob[i] /= s;
-        std::sort(u.begin(), u.end());
-        for (int i = 0; i < Np; ++i)
+        typedef std::vector<D::result_type>::iterator I;
+        I lb = std::lower_bound(u.begin(), u.end(), b[i]);
+        I ub = std::lower_bound(u.begin(), u.end(), b[i+1]);
+        const size_t Ni = ub - lb;
+        if (prob[i] == 0)
+            assert(Ni == 0);
+        else
         {
-            typedef std::vector<D::result_type>::iterator I;
-            I lb = std::lower_bound(u.begin(), u.end(), b[i]);
-            I ub = std::lower_bound(u.begin(), u.end(), b[i+1]);
-            const size_t Ni = ub - lb;
-            if (prob[i] == 0)
-                assert(Ni == 0);
-            else
+            assert(std::abs((double)Ni/N - prob[i]) / prob[i] < .01);
+            double mean = std::accumulate(lb, ub, 0.0) / Ni;
+            double var = 0;
+            double skew = 0;
+            double kurtosis = 0;
+            for (I j = lb; j != ub; ++j)
             {
-                assert(std::abs((double)Ni/N - prob[i]) / prob[i] < .01);
-                double mean = std::accumulate(lb, ub, 0.0) / Ni;
-                double var = 0;
-                double skew = 0;
-                double kurtosis = 0;
-                for (I j = lb; j != ub; ++j)
-                {
-                    double d = (*j - mean);
-                    double d2 = sqr(d);
-                    var += d2;
-                    skew += d * d2;
-                    kurtosis += d2 * d2;
-                }
-                var /= Ni;
-                double dev = std::sqrt(var);
-                skew /= Ni * dev * var;
-                kurtosis /= Ni * var * var;
-                kurtosis -= 3;
-                double x_mean = (b[i+1] + b[i]) / 2;
-                double x_var = sqr(b[i+1] - b[i]) / 12;
-                double x_skew = 0;
-                double x_kurtosis = -6./5;
-                assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-                assert(std::abs((var - x_var) / x_var) < 0.01);
-                assert(std::abs(skew - x_skew) < 0.01);
-                assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+                double dbl = (*j - mean);
+                double d2 = sqr(dbl);
+                var += d2;
+                skew += dbl * d2;
+                kurtosis += d2 * d2;
             }
+            var /= Ni;
+            double dev = std::sqrt(var);
+            skew /= Ni * dev * var;
+            kurtosis /= Ni * var * var;
+            kurtosis -= 3;
+            double x_mean = (b[i+1] + b[i]) / 2;
+            double x_var = sqr(b[i+1] - b[i]) / 12;
+            double x_skew = 0;
+            double x_kurtosis = -6./5;
+            assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+            assert(std::abs((var - x_var) / x_var) < 0.01);
+            assert(std::abs(skew - x_skew) < 0.01);
+            assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
         }
     }
+}
+
+void
+test7()
+{
+    typedef std::piecewise_constant_distribution<> D;
+    typedef std::mt19937_64 G;
+    G g;
+    double b[] = {10, 14, 16, 17};
+    double p[] = {0, 0, 1};
+    const size_t Np = sizeof(p) / sizeof(p[0]);
+    D d(b, b+Np+1, p);
+    const int N = 100000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
     {
-        typedef std::piecewise_constant_distribution<> D;
-        typedef std::mt19937_64 G;
-        G g;
-        double b[] = {10, 14, 16, 17};
-        double p[] = {0, 0, 1};
-        const size_t Np = sizeof(p) / sizeof(p[0]);
-        D d(b, b+Np+1, p);
-        const int N = 100000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v < d.max());
-            u.push_back(v);
-        }
-        std::vector<double> prob(std::begin(p), std::end(p));
-        double s = std::accumulate(prob.begin(), prob.end(), 0.0);
-        for (int i = 0; i < prob.size(); ++i)
-            prob[i] /= s;
-        std::sort(u.begin(), u.end());
-        for (int i = 0; i < Np; ++i)
+        D::result_type v = d(g);
+        assert(d.min() <= v && v < d.max());
+        u.push_back(v);
+    }
+    std::vector<double> prob(std::begin(p), std::end(p));
+    double s = std::accumulate(prob.begin(), prob.end(), 0.0);
+    for (int i = 0; i < prob.size(); ++i)
+        prob[i] /= s;
+    std::sort(u.begin(), u.end());
+    for (int i = 0; i < Np; ++i)
+    {
+        typedef std::vector<D::result_type>::iterator I;
+        I lb = std::lower_bound(u.begin(), u.end(), b[i]);
+        I ub = std::lower_bound(u.begin(), u.end(), b[i+1]);
+        const size_t Ni = ub - lb;
+        if (prob[i] == 0)
+            assert(Ni == 0);
+        else
         {
-            typedef std::vector<D::result_type>::iterator I;
-            I lb = std::lower_bound(u.begin(), u.end(), b[i]);
-            I ub = std::lower_bound(u.begin(), u.end(), b[i+1]);
-            const size_t Ni = ub - lb;
-            if (prob[i] == 0)
-                assert(Ni == 0);
-            else
+            assert(std::abs((double)Ni/N - prob[i]) / prob[i] < .01);
+            double mean = std::accumulate(lb, ub, 0.0) / Ni;
+            double var = 0;
+            double skew = 0;
+            double kurtosis = 0;
+            for (I j = lb; j != ub; ++j)
             {
-                assert(std::abs((double)Ni/N - prob[i]) / prob[i] < .01);
-                double mean = std::accumulate(lb, ub, 0.0) / Ni;
-                double var = 0;
-                double skew = 0;
-                double kurtosis = 0;
-                for (I j = lb; j != ub; ++j)
-                {
-                    double d = (*j - mean);
-                    double d2 = sqr(d);
-                    var += d2;
-                    skew += d * d2;
-                    kurtosis += d2 * d2;
-                }
-                var /= Ni;
-                double dev = std::sqrt(var);
-                skew /= Ni * dev * var;
-                kurtosis /= Ni * var * var;
-                kurtosis -= 3;
-                double x_mean = (b[i+1] + b[i]) / 2;
-                double x_var = sqr(b[i+1] - b[i]) / 12;
-                double x_skew = 0;
-                double x_kurtosis = -6./5;
-                assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-                assert(std::abs((var - x_var) / x_var) < 0.01);
-                assert(std::abs(skew - x_skew) < 0.01);
-                assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+                double dbl = (*j - mean);
+                double d2 = sqr(dbl);
+                var += d2;
+                skew += dbl * d2;
+                kurtosis += d2 * d2;
             }
+            var /= Ni;
+            double dev = std::sqrt(var);
+            skew /= Ni * dev * var;
+            kurtosis /= Ni * var * var;
+            kurtosis -= 3;
+            double x_mean = (b[i+1] + b[i]) / 2;
+            double x_var = sqr(b[i+1] - b[i]) / 12;
+            double x_skew = 0;
+            double x_kurtosis = -6./5;
+            assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+            assert(std::abs((var - x_var) / x_var) < 0.01);
+            assert(std::abs(skew - x_skew) < 0.01);
+            assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
         }
     }
+}
+
+void
+test8()
+{
+    typedef std::piecewise_constant_distribution<> D;
+    typedef std::mt19937_64 G;
+    G g;
+    double b[] = {10, 14, 16};
+    double p[] = {75, 25};
+    const size_t Np = sizeof(p) / sizeof(p[0]);
+    D d(b, b+Np+1, p);
+    const int N = 100000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
+    {
+        D::result_type v = d(g);
+        assert(d.min() <= v && v < d.max());
+        u.push_back(v);
+    }
+    std::vector<double> prob(std::begin(p), std::end(p));
+    double s = std::accumulate(prob.begin(), prob.end(), 0.0);
+    for (int i = 0; i < prob.size(); ++i)
+        prob[i] /= s;
+    std::sort(u.begin(), u.end());
+    for (int i = 0; i < Np; ++i)
     {
-        typedef std::piecewise_constant_distribution<> D;
-        typedef std::mt19937_64 G;
-        G g;
-        double b[] = {10, 14, 16};
-        double p[] = {75, 25};
-        const size_t Np = sizeof(p) / sizeof(p[0]);
-        D d(b, b+Np+1, p);
-        const int N = 100000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
+        typedef std::vector<D::result_type>::iterator I;
+        I lb = std::lower_bound(u.begin(), u.end(), b[i]);
+        I ub = std::lower_bound(u.begin(), u.end(), b[i+1]);
+        const size_t Ni = ub - lb;
+        if (prob[i] == 0)
+            assert(Ni == 0);
+        else
         {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v < d.max());
-            u.push_back(v);
-        }
-        std::vector<double> prob(std::begin(p), std::end(p));
-        double s = std::accumulate(prob.begin(), prob.end(), 0.0);
-        for (int i = 0; i < prob.size(); ++i)
-            prob[i] /= s;
-        std::sort(u.begin(), u.end());
-        for (int i = 0; i < Np; ++i)
-        {
-            typedef std::vector<D::result_type>::iterator I;
-            I lb = std::lower_bound(u.begin(), u.end(), b[i]);
-            I ub = std::lower_bound(u.begin(), u.end(), b[i+1]);
-            const size_t Ni = ub - lb;
-            if (prob[i] == 0)
-                assert(Ni == 0);
-            else
+            assert(std::abs((double)Ni/N - prob[i]) / prob[i] < .01);
+            double mean = std::accumulate(lb, ub, 0.0) / Ni;
+            double var = 0;
+            double skew = 0;
+            double kurtosis = 0;
+            for (I j = lb; j != ub; ++j)
             {
-                assert(std::abs((double)Ni/N - prob[i]) / prob[i] < .01);
-                double mean = std::accumulate(lb, ub, 0.0) / Ni;
-                double var = 0;
-                double skew = 0;
-                double kurtosis = 0;
-                for (I j = lb; j != ub; ++j)
-                {
-                    double d = (*j - mean);
-                    double d2 = sqr(d);
-                    var += d2;
-                    skew += d * d2;
-                    kurtosis += d2 * d2;
-                }
-                var /= Ni;
-                double dev = std::sqrt(var);
-                skew /= Ni * dev * var;
-                kurtosis /= Ni * var * var;
-                kurtosis -= 3;
-                double x_mean = (b[i+1] + b[i]) / 2;
-                double x_var = sqr(b[i+1] - b[i]) / 12;
-                double x_skew = 0;
-                double x_kurtosis = -6./5;
-                assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-                assert(std::abs((var - x_var) / x_var) < 0.01);
-                assert(std::abs(skew - x_skew) < 0.01);
-                assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+                double dbl = (*j - mean);
+                double d2 = sqr(dbl);
+                var += d2;
+                skew += dbl * d2;
+                kurtosis += d2 * d2;
             }
+            var /= Ni;
+            double dev = std::sqrt(var);
+            skew /= Ni * dev * var;
+            kurtosis /= Ni * var * var;
+            kurtosis -= 3;
+            double x_mean = (b[i+1] + b[i]) / 2;
+            double x_var = sqr(b[i+1] - b[i]) / 12;
+            double x_skew = 0;
+            double x_kurtosis = -6./5;
+            assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+            assert(std::abs((var - x_var) / x_var) < 0.01);
+            assert(std::abs(skew - x_skew) < 0.01);
+            assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
         }
     }
+}
+
+void
+test9()
+{
+    typedef std::piecewise_constant_distribution<> D;
+    typedef std::mt19937_64 G;
+    G g;
+    double b[] = {10, 14, 16};
+    double p[] = {0, 25};
+    const size_t Np = sizeof(p) / sizeof(p[0]);
+    D d(b, b+Np+1, p);
+    const int N = 100000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
     {
-        typedef std::piecewise_constant_distribution<> D;
-        typedef std::mt19937_64 G;
-        G g;
-        double b[] = {10, 14, 16};
-        double p[] = {0, 25};
-        const size_t Np = sizeof(p) / sizeof(p[0]);
-        D d(b, b+Np+1, p);
-        const int N = 100000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v < d.max());
-            u.push_back(v);
-        }
-        std::vector<double> prob(std::begin(p), std::end(p));
-        double s = std::accumulate(prob.begin(), prob.end(), 0.0);
-        for (int i = 0; i < prob.size(); ++i)
-            prob[i] /= s;
-        std::sort(u.begin(), u.end());
-        for (int i = 0; i < Np; ++i)
+        D::result_type v = d(g);
+        assert(d.min() <= v && v < d.max());
+        u.push_back(v);
+    }
+    std::vector<double> prob(std::begin(p), std::end(p));
+    double s = std::accumulate(prob.begin(), prob.end(), 0.0);
+    for (int i = 0; i < prob.size(); ++i)
+        prob[i] /= s;
+    std::sort(u.begin(), u.end());
+    for (int i = 0; i < Np; ++i)
+    {
+        typedef std::vector<D::result_type>::iterator I;
+        I lb = std::lower_bound(u.begin(), u.end(), b[i]);
+        I ub = std::lower_bound(u.begin(), u.end(), b[i+1]);
+        const size_t Ni = ub - lb;
+        if (prob[i] == 0)
+            assert(Ni == 0);
+        else
         {
-            typedef std::vector<D::result_type>::iterator I;
-            I lb = std::lower_bound(u.begin(), u.end(), b[i]);
-            I ub = std::lower_bound(u.begin(), u.end(), b[i+1]);
-            const size_t Ni = ub - lb;
-            if (prob[i] == 0)
-                assert(Ni == 0);
-            else
+            assert(std::abs((double)Ni/N - prob[i]) / prob[i] < .01);
+            double mean = std::accumulate(lb, ub, 0.0) / Ni;
+            double var = 0;
+            double skew = 0;
+            double kurtosis = 0;
+            for (I j = lb; j != ub; ++j)
             {
-                assert(std::abs((double)Ni/N - prob[i]) / prob[i] < .01);
-                double mean = std::accumulate(lb, ub, 0.0) / Ni;
-                double var = 0;
-                double skew = 0;
-                double kurtosis = 0;
-                for (I j = lb; j != ub; ++j)
-                {
-                    double d = (*j - mean);
-                    double d2 = sqr(d);
-                    var += d2;
-                    skew += d * d2;
-                    kurtosis += d2 * d2;
-                }
-                var /= Ni;
-                double dev = std::sqrt(var);
-                skew /= Ni * dev * var;
-                kurtosis /= Ni * var * var;
-                kurtosis -= 3;
-                double x_mean = (b[i+1] + b[i]) / 2;
-                double x_var = sqr(b[i+1] - b[i]) / 12;
-                double x_skew = 0;
-                double x_kurtosis = -6./5;
-                assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-                assert(std::abs((var - x_var) / x_var) < 0.01);
-                assert(std::abs(skew - x_skew) < 0.01);
-                assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+                double dbl = (*j - mean);
+                double d2 = sqr(dbl);
+                var += d2;
+                skew += dbl * d2;
+                kurtosis += d2 * d2;
             }
+            var /= Ni;
+            double dev = std::sqrt(var);
+            skew /= Ni * dev * var;
+            kurtosis /= Ni * var * var;
+            kurtosis -= 3;
+            double x_mean = (b[i+1] + b[i]) / 2;
+            double x_var = sqr(b[i+1] - b[i]) / 12;
+            double x_skew = 0;
+            double x_kurtosis = -6./5;
+            assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+            assert(std::abs((var - x_var) / x_var) < 0.01);
+            assert(std::abs(skew - x_skew) < 0.01);
+            assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
         }
     }
+}
+
+void
+test10()
+{
+    typedef std::piecewise_constant_distribution<> D;
+    typedef std::mt19937_64 G;
+    G g;
+    double b[] = {10, 14, 16};
+    double p[] = {1, 0};
+    const size_t Np = sizeof(p) / sizeof(p[0]);
+    D d(b, b+Np+1, p);
+    const int N = 100000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
     {
-        typedef std::piecewise_constant_distribution<> D;
-        typedef std::mt19937_64 G;
-        G g;
-        double b[] = {10, 14, 16};
-        double p[] = {1, 0};
-        const size_t Np = sizeof(p) / sizeof(p[0]);
-        D d(b, b+Np+1, p);
-        const int N = 100000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v < d.max());
-            u.push_back(v);
-        }
-        std::vector<double> prob(std::begin(p), std::end(p));
-        double s = std::accumulate(prob.begin(), prob.end(), 0.0);
-        for (int i = 0; i < prob.size(); ++i)
-            prob[i] /= s;
-        std::sort(u.begin(), u.end());
-        for (int i = 0; i < Np; ++i)
+        D::result_type v = d(g);
+        assert(d.min() <= v && v < d.max());
+        u.push_back(v);
+    }
+    std::vector<double> prob(std::begin(p), std::end(p));
+    double s = std::accumulate(prob.begin(), prob.end(), 0.0);
+    for (int i = 0; i < prob.size(); ++i)
+        prob[i] /= s;
+    std::sort(u.begin(), u.end());
+    for (int i = 0; i < Np; ++i)
+    {
+        typedef std::vector<D::result_type>::iterator I;
+        I lb = std::lower_bound(u.begin(), u.end(), b[i]);
+        I ub = std::lower_bound(u.begin(), u.end(), b[i+1]);
+        const size_t Ni = ub - lb;
+        if (prob[i] == 0)
+            assert(Ni == 0);
+        else
         {
-            typedef std::vector<D::result_type>::iterator I;
-            I lb = std::lower_bound(u.begin(), u.end(), b[i]);
-            I ub = std::lower_bound(u.begin(), u.end(), b[i+1]);
-            const size_t Ni = ub - lb;
-            if (prob[i] == 0)
-                assert(Ni == 0);
-            else
+            assert(std::abs((double)Ni/N - prob[i]) / prob[i] < .01);
+            double mean = std::accumulate(lb, ub, 0.0) / Ni;
+            double var = 0;
+            double skew = 0;
+            double kurtosis = 0;
+            for (I j = lb; j != ub; ++j)
             {
-                assert(std::abs((double)Ni/N - prob[i]) / prob[i] < .01);
-                double mean = std::accumulate(lb, ub, 0.0) / Ni;
-                double var = 0;
-                double skew = 0;
-                double kurtosis = 0;
-                for (I j = lb; j != ub; ++j)
-                {
-                    double d = (*j - mean);
-                    double d2 = sqr(d);
-                    var += d2;
-                    skew += d * d2;
-                    kurtosis += d2 * d2;
-                }
-                var /= Ni;
-                double dev = std::sqrt(var);
-                skew /= Ni * dev * var;
-                kurtosis /= Ni * var * var;
-                kurtosis -= 3;
-                double x_mean = (b[i+1] + b[i]) / 2;
-                double x_var = sqr(b[i+1] - b[i]) / 12;
-                double x_skew = 0;
-                double x_kurtosis = -6./5;
-                assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-                assert(std::abs((var - x_var) / x_var) < 0.01);
-                assert(std::abs(skew - x_skew) < 0.01);
-                assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+                double dbl = (*j - mean);
+                double d2 = sqr(dbl);
+                var += d2;
+                skew += dbl * d2;
+                kurtosis += d2 * d2;
             }
+            var /= Ni;
+            double dev = std::sqrt(var);
+            skew /= Ni * dev * var;
+            kurtosis /= Ni * var * var;
+            kurtosis -= 3;
+            double x_mean = (b[i+1] + b[i]) / 2;
+            double x_var = sqr(b[i+1] - b[i]) / 12;
+            double x_skew = 0;
+            double x_kurtosis = -6./5;
+            assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+            assert(std::abs((var - x_var) / x_var) < 0.01);
+            assert(std::abs(skew - x_skew) < 0.01);
+            assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
         }
     }
+}
+
+void
+test11()
+{
+    typedef std::piecewise_constant_distribution<> D;
+    typedef std::mt19937_64 G;
+    G g;
+    double b[] = {10, 14};
+    double p[] = {1};
+    const size_t Np = sizeof(p) / sizeof(p[0]);
+    D d(b, b+Np+1, p);
+    const int N = 100000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
     {
-        typedef std::piecewise_constant_distribution<> D;
-        typedef std::mt19937_64 G;
-        G g;
-        double b[] = {10, 14};
-        double p[] = {1};
-        const size_t Np = sizeof(p) / sizeof(p[0]);
-        D d(b, b+Np+1, p);
-        const int N = 100000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v < d.max());
-            u.push_back(v);
-        }
-        std::vector<double> prob(std::begin(p), std::end(p));
-        double s = std::accumulate(prob.begin(), prob.end(), 0.0);
-        for (int i = 0; i < prob.size(); ++i)
-            prob[i] /= s;
-        std::sort(u.begin(), u.end());
-        for (int i = 0; i < Np; ++i)
+        D::result_type v = d(g);
+        assert(d.min() <= v && v < d.max());
+        u.push_back(v);
+    }
+    std::vector<double> prob(std::begin(p), std::end(p));
+    double s = std::accumulate(prob.begin(), prob.end(), 0.0);
+    for (int i = 0; i < prob.size(); ++i)
+        prob[i] /= s;
+    std::sort(u.begin(), u.end());
+    for (int i = 0; i < Np; ++i)
+    {
+        typedef std::vector<D::result_type>::iterator I;
+        I lb = std::lower_bound(u.begin(), u.end(), b[i]);
+        I ub = std::lower_bound(u.begin(), u.end(), b[i+1]);
+        const size_t Ni = ub - lb;
+        if (prob[i] == 0)
+            assert(Ni == 0);
+        else
         {
-            typedef std::vector<D::result_type>::iterator I;
-            I lb = std::lower_bound(u.begin(), u.end(), b[i]);
-            I ub = std::lower_bound(u.begin(), u.end(), b[i+1]);
-            const size_t Ni = ub - lb;
-            if (prob[i] == 0)
-                assert(Ni == 0);
-            else
+            assert(std::abs((double)Ni/N - prob[i]) / prob[i] < .01);
+            double mean = std::accumulate(lb, ub, 0.0) / Ni;
+            double var = 0;
+            double skew = 0;
+            double kurtosis = 0;
+            for (I j = lb; j != ub; ++j)
             {
-                assert(std::abs((double)Ni/N - prob[i]) / prob[i] < .01);
-                double mean = std::accumulate(lb, ub, 0.0) / Ni;
-                double var = 0;
-                double skew = 0;
-                double kurtosis = 0;
-                for (I j = lb; j != ub; ++j)
-                {
-                    double d = (*j - mean);
-                    double d2 = sqr(d);
-                    var += d2;
-                    skew += d * d2;
-                    kurtosis += d2 * d2;
-                }
-                var /= Ni;
-                double dev = std::sqrt(var);
-                skew /= Ni * dev * var;
-                kurtosis /= Ni * var * var;
-                kurtosis -= 3;
-                double x_mean = (b[i+1] + b[i]) / 2;
-                double x_var = sqr(b[i+1] - b[i]) / 12;
-                double x_skew = 0;
-                double x_kurtosis = -6./5;
-                assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-                assert(std::abs((var - x_var) / x_var) < 0.01);
-                assert(std::abs(skew - x_skew) < 0.01);
-                assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
+                double dbl = (*j - mean);
+                double d2 = sqr(dbl);
+                var += d2;
+                skew += dbl * d2;
+                kurtosis += d2 * d2;
             }
+            var /= Ni;
+            double dev = std::sqrt(var);
+            skew /= Ni * dev * var;
+            kurtosis /= Ni * var * var;
+            kurtosis -= 3;
+            double x_mean = (b[i+1] + b[i]) / 2;
+            double x_var = sqr(b[i+1] - b[i]) / 12;
+            double x_skew = 0;
+            double x_kurtosis = -6./5;
+            assert(std::abs((mean - x_mean) / x_mean) < 0.01);
+            assert(std::abs((var - x_var) / x_var) < 0.01);
+            assert(std::abs(skew - x_skew) < 0.01);
+            assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
         }
     }
 }
+
+int main()
+{
+    test1();
+    test2();
+    test3();
+    test4();
+    test5();
+    test6();
+    test7();
+    test8();
+    test9();
+    test10();
+    test11();
+}
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval_param.pass.cpp
index 6850115875bb..ffd53c05d37e 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval_param.pass.cpp
@@ -17,6 +17,7 @@
 // template<class _URNG> result_type operator()(_URNG& g, const param_type& parm);
 
 #include <random>
+#include <algorithm>
 #include <vector>
 #include <iterator>
 #include <numeric>
@@ -72,10 +73,10 @@ int main()
                 double kurtosis = 0;
                 for (I j = lb; j != ub; ++j)
                 {
-                    double d = (*j - mean);
-                    double d2 = sqr(d);
+                    double dbl = (*j - mean);
+                    double d2 = sqr(dbl);
                     var += d2;
-                    skew += d * d2;
+                    skew += dbl * d2;
                     kurtosis += d2 * d2;
                 }
                 var /= Ni;
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval.pass.cpp
index af75fce512e4..03da9b8960e4 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval.pass.cpp
@@ -19,10 +19,12 @@
 #include <iostream>
 
 #include <random>
+#include <algorithm>
 #include <vector>
 #include <iterator>
 #include <numeric>
 #include <cassert>
+#include <limits>
 
 template <class T>
 inline
@@ -38,306 +40,333 @@ f(double x, double a, double m, double b, double c)
     return a + m*(sqr(x) - sqr(b))/2 + c*(x-b);
 }
 
-int main()
+void
+test1()
 {
+    typedef std::piecewise_linear_distribution<> D;
+    typedef D::param_type P;
+    typedef std::mt19937_64 G;
+    G g;
+    double b[] = {10, 14, 16, 17};
+    double p[] = {0, 1, 1, 0};
+    const size_t Np = sizeof(p) / sizeof(p[0]) - 1;
+    D d(b, b+Np+1, p);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
     {
-        typedef std::piecewise_linear_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937_64 G;
-        G g;
-        double b[] = {10, 14, 16, 17};
-        double p[] = {0, 1, 1, 0};
-        const size_t Np = sizeof(p) / sizeof(p[0]) - 1;
-        D d(b, b+Np+1, p);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v < d.max());
-            u.push_back(v);
-        }
-        std::sort(u.begin(), u.end());
-        int kp = -1;
-        double a;
-        double m;
-        double bk;
-        double c;
-        std::vector<double> areas(Np);
-        double S = 0;
-        for (int i = 0; i < areas.size(); ++i)
-        {
-            areas[i] = (p[i]+p[i+1])*(b[i+1]-b[i])/2;
-            S += areas[i];
-        }
-        for (int i = 0; i < areas.size(); ++i)
-            areas[i] /= S;
-        for (int i = 0; i < Np+1; ++i)
-            p[i] /= S;
-        for (int i = 0; i < N; ++i)
-        {
-            int k = std::lower_bound(b, b+Np+1, u[i]) - b - 1;
-            if (k != kp)
-            {
-                a = 0;
-                for (int j = 0; j < k; ++j)
-                    a += areas[j];
-                m = (p[k+1] - p[k]) / (b[k+1] - b[k]);
-                bk = b[k];
-                c = (b[k+1]*p[k] - b[k]*p[k+1]) / (b[k+1] - b[k]);
-                kp = k;
-            }
-            assert(std::abs(f(u[i], a, m, bk, c) - double(i)/N) < .001);
-        }
+        D::result_type v = d(g);
+        assert(d.min() <= v && v < d.max());
+        u.push_back(v);
     }
+    std::sort(u.begin(), u.end());
+    int kp = -1;
+    double a = std::numeric_limits<double>::quiet_NaN();
+    double m = std::numeric_limits<double>::quiet_NaN();
+    double bk = std::numeric_limits<double>::quiet_NaN();
+    double c = std::numeric_limits<double>::quiet_NaN();
+    std::vector<double> areas(Np);
+    double S = 0;
+    for (int i = 0; i < areas.size(); ++i)
     {
-        typedef std::piecewise_linear_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937_64 G;
-        G g;
-        double b[] = {10, 14, 16, 17};
-        double p[] = {0, 0, 1, 0};
-        const size_t Np = sizeof(p) / sizeof(p[0]) - 1;
-        D d(b, b+Np+1, p);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v < d.max());
-            u.push_back(v);
-        }
-        std::sort(u.begin(), u.end());
-        int kp = -1;
-        double a;
-        double m;
-        double bk;
-        double c;
-        std::vector<double> areas(Np);
-        double S = 0;
-        for (int i = 0; i < areas.size(); ++i)
-        {
-            areas[i] = (p[i]+p[i+1])*(b[i+1]-b[i])/2;
-            S += areas[i];
-        }
-        for (int i = 0; i < areas.size(); ++i)
-            areas[i] /= S;
-        for (int i = 0; i < Np+1; ++i)
-            p[i] /= S;
-        for (int i = 0; i < N; ++i)
-        {
-            int k = std::lower_bound(b, b+Np+1, u[i]) - b - 1;
-            if (k != kp)
-            {
-                a = 0;
-                for (int j = 0; j < k; ++j)
-                    a += areas[j];
-                m = (p[k+1] - p[k]) / (b[k+1] - b[k]);
-                bk = b[k];
-                c = (b[k+1]*p[k] - b[k]*p[k+1]) / (b[k+1] - b[k]);
-                kp = k;
-            }
-            assert(std::abs(f(u[i], a, m, bk, c) - double(i)/N) < .001);
-        }
+        areas[i] = (p[i]+p[i+1])*(b[i+1]-b[i])/2;
+        S += areas[i];
     }
+    for (int i = 0; i < areas.size(); ++i)
+        areas[i] /= S;
+    for (int i = 0; i < Np+1; ++i)
+        p[i] /= S;
+    for (int i = 0; i < N; ++i)
     {
-        typedef std::piecewise_linear_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937_64 G;
-        G g;
-        double b[] = {10, 14, 16, 17};
-        double p[] = {1, 0, 0, 0};
-        const size_t Np = sizeof(p) / sizeof(p[0]) - 1;
-        D d(b, b+Np+1, p);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v < d.max());
-            u.push_back(v);
-        }
-        std::sort(u.begin(), u.end());
-        int kp = -1;
-        double a;
-        double m;
-        double bk;
-        double c;
-        std::vector<double> areas(Np);
-        double S = 0;
-        for (int i = 0; i < areas.size(); ++i)
-        {
-            areas[i] = (p[i]+p[i+1])*(b[i+1]-b[i])/2;
-            S += areas[i];
-        }
-        for (int i = 0; i < areas.size(); ++i)
-            areas[i] /= S;
-        for (int i = 0; i < Np+1; ++i)
-            p[i] /= S;
-        for (int i = 0; i < N; ++i)
+        int k = std::lower_bound(b, b+Np+1, u[i]) - b - 1;
+        if (k != kp)
         {
-            int k = std::lower_bound(b, b+Np+1, u[i]) - b - 1;
-            if (k != kp)
-            {
-                a = 0;
-                for (int j = 0; j < k; ++j)
-                    a += areas[j];
-                m = (p[k+1] - p[k]) / (b[k+1] - b[k]);
-                bk = b[k];
-                c = (b[k+1]*p[k] - b[k]*p[k+1]) / (b[k+1] - b[k]);
-                kp = k;
-            }
-            assert(std::abs(f(u[i], a, m, bk, c) - double(i)/N) < .001);
+            a = 0;
+            for (int j = 0; j < k; ++j)
+                a += areas[j];
+            m = (p[k+1] - p[k]) / (b[k+1] - b[k]);
+            bk = b[k];
+            c = (b[k+1]*p[k] - b[k]*p[k+1]) / (b[k+1] - b[k]);
+            kp = k;
         }
+        assert(std::abs(f(u[i], a, m, bk, c) - double(i)/N) < .001);
     }
+}
+
+void
+test2()
+{
+    typedef std::piecewise_linear_distribution<> D;
+    typedef D::param_type P;
+    typedef std::mt19937_64 G;
+    G g;
+    double b[] = {10, 14, 16, 17};
+    double p[] = {0, 0, 1, 0};
+    const size_t Np = sizeof(p) / sizeof(p[0]) - 1;
+    D d(b, b+Np+1, p);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
     {
-        typedef std::piecewise_linear_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937_64 G;
-        G g;
-        double b[] = {10, 14, 16};
-        double p[] = {0, 1, 0};
-        const size_t Np = sizeof(p) / sizeof(p[0]) - 1;
-        D d(b, b+Np+1, p);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v < d.max());
-            u.push_back(v);
-        }
-        std::sort(u.begin(), u.end());
-        int kp = -1;
-        double a;
-        double m;
-        double bk;
-        double c;
-        std::vector<double> areas(Np);
-        double S = 0;
-        for (int i = 0; i < areas.size(); ++i)
-        {
-            areas[i] = (p[i]+p[i+1])*(b[i+1]-b[i])/2;
-            S += areas[i];
-        }
-        for (int i = 0; i < areas.size(); ++i)
-            areas[i] /= S;
-        for (int i = 0; i < Np+1; ++i)
-            p[i] /= S;
-        for (int i = 0; i < N; ++i)
-        {
-            int k = std::lower_bound(b, b+Np+1, u[i]) - b - 1;
-            if (k != kp)
-            {
-                a = 0;
-                for (int j = 0; j < k; ++j)
-                    a += areas[j];
-                m = (p[k+1] - p[k]) / (b[k+1] - b[k]);
-                bk = b[k];
-                c = (b[k+1]*p[k] - b[k]*p[k+1]) / (b[k+1] - b[k]);
-                kp = k;
-            }
-            assert(std::abs(f(u[i], a, m, bk, c) - double(i)/N) < .001);
-        }
+        D::result_type v = d(g);
+        assert(d.min() <= v && v < d.max());
+        u.push_back(v);
     }
+    std::sort(u.begin(), u.end());
+    int kp = -1;
+    double a = std::numeric_limits<double>::quiet_NaN();
+    double m = std::numeric_limits<double>::quiet_NaN();
+    double bk = std::numeric_limits<double>::quiet_NaN();
+    double c = std::numeric_limits<double>::quiet_NaN();
+    std::vector<double> areas(Np);
+    double S = 0;
+    for (int i = 0; i < areas.size(); ++i)
     {
-        typedef std::piecewise_linear_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937_64 G;
-        G g;
-        double b[] = {10, 14};
-        double p[] = {1, 1};
-        const size_t Np = sizeof(p) / sizeof(p[0]) - 1;
-        D d(b, b+Np+1, p);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v < d.max());
-            u.push_back(v);
-        }
-        std::sort(u.begin(), u.end());
-        int kp = -1;
-        double a;
-        double m;
-        double bk;
-        double c;
-        std::vector<double> areas(Np);
-        double S = 0;
-        for (int i = 0; i < areas.size(); ++i)
+        areas[i] = (p[i]+p[i+1])*(b[i+1]-b[i])/2;
+        S += areas[i];
+    }
+    for (int i = 0; i < areas.size(); ++i)
+        areas[i] /= S;
+    for (int i = 0; i < Np+1; ++i)
+        p[i] /= S;
+    for (int i = 0; i < N; ++i)
+    {
+        int k = std::lower_bound(b, b+Np+1, u[i]) - b - 1;
+        if (k != kp)
         {
-            areas[i] = (p[i]+p[i+1])*(b[i+1]-b[i])/2;
-            S += areas[i];
+            a = 0;
+            for (int j = 0; j < k; ++j)
+                a += areas[j];
+            m = (p[k+1] - p[k]) / (b[k+1] - b[k]);
+            bk = b[k];
+            c = (b[k+1]*p[k] - b[k]*p[k+1]) / (b[k+1] - b[k]);
+            kp = k;
         }
-        for (int i = 0; i < areas.size(); ++i)
-            areas[i] /= S;
-        for (int i = 0; i < Np+1; ++i)
-            p[i] /= S;
-        for (int i = 0; i < N; ++i)
+        assert(std::abs(f(u[i], a, m, bk, c) - double(i)/N) < .001);
+    }
+}
+
+void
+test3()
+{
+    typedef std::piecewise_linear_distribution<> D;
+    typedef D::param_type P;
+    typedef std::mt19937_64 G;
+    G g;
+    double b[] = {10, 14, 16, 17};
+    double p[] = {1, 0, 0, 0};
+    const size_t Np = sizeof(p) / sizeof(p[0]) - 1;
+    D d(b, b+Np+1, p);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
+    {
+        D::result_type v = d(g);
+        assert(d.min() <= v && v < d.max());
+        u.push_back(v);
+    }
+    std::sort(u.begin(), u.end());
+    int kp = -1;
+    double a = std::numeric_limits<double>::quiet_NaN();
+    double m = std::numeric_limits<double>::quiet_NaN();
+    double bk = std::numeric_limits<double>::quiet_NaN();
+    double c = std::numeric_limits<double>::quiet_NaN();
+    std::vector<double> areas(Np);
+    double S = 0;
+    for (int i = 0; i < areas.size(); ++i)
+    {
+        areas[i] = (p[i]+p[i+1])*(b[i+1]-b[i])/2;
+        S += areas[i];
+    }
+    for (int i = 0; i < areas.size(); ++i)
+        areas[i] /= S;
+    for (int i = 0; i < Np+1; ++i)
+        p[i] /= S;
+    for (int i = 0; i < N; ++i)
+    {
+        int k = std::lower_bound(b, b+Np+1, u[i]) - b - 1;
+        if (k != kp)
         {
-            int k = std::lower_bound(b, b+Np+1, u[i]) - b - 1;
-            if (k != kp)
-            {
-                a = 0;
-                for (int j = 0; j < k; ++j)
-                    a += areas[j];
-                m = (p[k+1] - p[k]) / (b[k+1] - b[k]);
-                bk = b[k];
-                c = (b[k+1]*p[k] - b[k]*p[k+1]) / (b[k+1] - b[k]);
-                kp = k;
-            }
-            assert(std::abs(f(u[i], a, m, bk, c) - double(i)/N) < .001);
+            a = 0;
+            for (int j = 0; j < k; ++j)
+                a += areas[j];
+            m = (p[k+1] - p[k]) / (b[k+1] - b[k]);
+            bk = b[k];
+            c = (b[k+1]*p[k] - b[k]*p[k+1]) / (b[k+1] - b[k]);
+            kp = k;
         }
+        assert(std::abs(f(u[i], a, m, bk, c) - double(i)/N) < .001);
     }
+}
+
+void
+test4()
+{
+    typedef std::piecewise_linear_distribution<> D;
+    typedef D::param_type P;
+    typedef std::mt19937_64 G;
+    G g;
+    double b[] = {10, 14, 16};
+    double p[] = {0, 1, 0};
+    const size_t Np = sizeof(p) / sizeof(p[0]) - 1;
+    D d(b, b+Np+1, p);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
     {
-        typedef std::piecewise_linear_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937_64 G;
-        G g;
-        double b[] = {10, 14, 16, 17};
-        double p[] = {25, 62.5, 12.5, 0};
-        const size_t Np = sizeof(p) / sizeof(p[0]) - 1;
-        D d(b, b+Np+1, p);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
+        D::result_type v = d(g);
+        assert(d.min() <= v && v < d.max());
+        u.push_back(v);
+    }
+    std::sort(u.begin(), u.end());
+    int kp = -1;
+    double a = std::numeric_limits<double>::quiet_NaN();
+    double m = std::numeric_limits<double>::quiet_NaN();
+    double bk = std::numeric_limits<double>::quiet_NaN();
+    double c = std::numeric_limits<double>::quiet_NaN();
+    std::vector<double> areas(Np);
+    double S = 0;
+    for (int i = 0; i < areas.size(); ++i)
+    {
+        areas[i] = (p[i]+p[i+1])*(b[i+1]-b[i])/2;
+        S += areas[i];
+    }
+    for (int i = 0; i < areas.size(); ++i)
+        areas[i] /= S;
+    for (int i = 0; i < Np+1; ++i)
+        p[i] /= S;
+    for (int i = 0; i < N; ++i)
+    {
+        int k = std::lower_bound(b, b+Np+1, u[i]) - b - 1;
+        if (k != kp)
         {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v < d.max());
-            u.push_back(v);
+            a = 0;
+            for (int j = 0; j < k; ++j)
+                a += areas[j];
+            assert(k < Np);
+            m = (p[k+1] - p[k]) / (b[k+1] - b[k]);
+            bk = b[k];
+            c = (b[k+1]*p[k] - b[k]*p[k+1]) / (b[k+1] - b[k]);
+            kp = k;
         }
-        std::sort(u.begin(), u.end());
-        int kp = -1;
-        double a;
-        double m;
-        double bk;
-        double c;
-        std::vector<double> areas(Np);
-        double S = 0;
-        for (int i = 0; i < areas.size(); ++i)
+        assert(std::abs(f(u[i], a, m, bk, c) - double(i)/N) < .001);
+    }
+}
+
+void
+test5()
+{
+    typedef std::piecewise_linear_distribution<> D;
+    typedef D::param_type P;
+    typedef std::mt19937_64 G;
+    G g;
+    double b[] = {10, 14};
+    double p[] = {1, 1};
+    const size_t Np = sizeof(p) / sizeof(p[0]) - 1;
+    D d(b, b+Np+1, p);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
+    {
+        D::result_type v = d(g);
+        assert(d.min() <= v && v < d.max());
+        u.push_back(v);
+    }
+    std::sort(u.begin(), u.end());
+    int kp = -1;
+    double a = std::numeric_limits<double>::quiet_NaN();
+    double m = std::numeric_limits<double>::quiet_NaN();
+    double bk = std::numeric_limits<double>::quiet_NaN();
+    double c = std::numeric_limits<double>::quiet_NaN();
+    std::vector<double> areas(Np);
+    double S = 0;
+    for (int i = 0; i < areas.size(); ++i)
+    {
+        assert(i < Np);
+        areas[i] = (p[i]+p[i+1])*(b[i+1]-b[i])/2;
+        S += areas[i];
+    }
+    for (int i = 0; i < areas.size(); ++i)
+        areas[i] /= S;
+    for (int i = 0; i < Np+1; ++i)
+        p[i] /= S;
+    for (int i = 0; i < N; ++i)
+    {
+        int k = std::lower_bound(b, b+Np+1, u[i]) - b - 1;
+        if (k != kp)
         {
-            areas[i] = (p[i]+p[i+1])*(b[i+1]-b[i])/2;
-            S += areas[i];
+            a = 0;
+            for (int j = 0; j < k; ++j)
+                a += areas[j];
+            assert(k < Np);
+            m = (p[k+1] - p[k]) / (b[k+1] - b[k]);
+            bk = b[k];
+            c = (b[k+1]*p[k] - b[k]*p[k+1]) / (b[k+1] - b[k]);
+            kp = k;
         }
-        for (int i = 0; i < areas.size(); ++i)
-            areas[i] /= S;
-        for (int i = 0; i < Np+1; ++i)
-            p[i] /= S;
-        for (int i = 0; i < N; ++i)
+        assert(std::abs(f(u[i], a, m, bk, c) - double(i)/N) < .001);
+    }
+}
+
+void
+test6()
+{
+    typedef std::piecewise_linear_distribution<> D;
+    typedef D::param_type P;
+    typedef std::mt19937_64 G;
+    G g;
+    double b[] = {10, 14, 16, 17};
+    double p[] = {25, 62.5, 12.5, 0};
+    const size_t Np = sizeof(p) / sizeof(p[0]) - 1;
+    D d(b, b+Np+1, p);
+    const int N = 1000000;
+    std::vector<D::result_type> u;
+    for (int i = 0; i < N; ++i)
+    {
+        D::result_type v = d(g);
+        assert(d.min() <= v && v < d.max());
+        u.push_back(v);
+    }
+    std::sort(u.begin(), u.end());
+    int kp = -1;
+    double a = std::numeric_limits<double>::quiet_NaN();
+    double m = std::numeric_limits<double>::quiet_NaN();
+    double bk = std::numeric_limits<double>::quiet_NaN();
+    double c = std::numeric_limits<double>::quiet_NaN();
+    std::vector<double> areas(Np);
+    double S = 0;
+    for (int i = 0; i < areas.size(); ++i)
+    {
+        areas[i] = (p[i]+p[i+1])*(b[i+1]-b[i])/2;
+        S += areas[i];
+    }
+    for (int i = 0; i < areas.size(); ++i)
+        areas[i] /= S;
+    for (int i = 0; i < Np+1; ++i)
+        p[i] /= S;
+    for (int i = 0; i < N; ++i)
+    {
+        int k = std::lower_bound(b, b+Np+1, u[i]) - b - 1;
+        if (k != kp)
         {
-            int k = std::lower_bound(b, b+Np+1, u[i]) - b - 1;
-            if (k != kp)
-            {
-                a = 0;
-                for (int j = 0; j < k; ++j)
-                    a += areas[j];
-                m = (p[k+1] - p[k]) / (b[k+1] - b[k]);
-                bk = b[k];
-                c = (b[k+1]*p[k] - b[k]*p[k+1]) / (b[k+1] - b[k]);
-                kp = k;
-            }
-            assert(std::abs(f(u[i], a, m, bk, c) - double(i)/N) < .001);
+            a = 0;
+            for (int j = 0; j < k; ++j)
+                a += areas[j];
+            m = (p[k+1] - p[k]) / (b[k+1] - b[k]);
+            bk = b[k];
+            c = (b[k+1]*p[k] - b[k]*p[k+1]) / (b[k+1] - b[k]);
+            kp = k;
         }
+        assert(std::abs(f(u[i], a, m, bk, c) - double(i)/N) < .001);
     }
 }
+
+int main()
+{
+    test1();
+    test2();
+    test3();
+    test4();
+    test5();
+    test6();
+}
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval_param.pass.cpp
index fe704228e788..8054a69fed87 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval_param.pass.cpp
@@ -20,7 +20,9 @@
 #include <vector>
 #include <iterator>
 #include <numeric>
+#include <algorithm>   // for sort
 #include <cassert>
+#include <limits>
 
 template <class T>
 inline
@@ -58,10 +60,10 @@ int main()
         }
         std::sort(u.begin(), u.end());
         int kp = -1;
-        double a;
-        double m;
-        double bk;
-        double c;
+        double a = std::numeric_limits<double>::quiet_NaN();
+        double m = std::numeric_limits<double>::quiet_NaN();
+        double bk = std::numeric_limits<double>::quiet_NaN();
+        double c = std::numeric_limits<double>::quiet_NaN();
         std::vector<double> areas(Np);
         double S = 0;
         for (int i = 0; i < areas.size(); ++i)
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp
index 66693a8da55b..2abc9d4c6dd5 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp
@@ -51,10 +51,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -92,10 +92,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -133,10 +133,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -174,10 +174,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -215,10 +215,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -256,10 +256,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -297,10 +297,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -338,10 +338,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -379,10 +379,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -431,10 +431,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval_param.pass.cpp
index d83d48cac1e3..849f25107fa8 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval_param.pass.cpp
@@ -51,10 +51,10 @@ int main()
         double kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            double d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval.pass.cpp
index 2663b2683bb4..e000363f3215 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval.pass.cpp
@@ -51,10 +51,10 @@ int main()
         D::result_type kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            D::result_type d = (u[i] - mean);
-            D::result_type d2 = sqr(d);
+            D::result_type dbl = (u[i] - mean);
+            D::result_type d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -91,10 +91,10 @@ int main()
         D::result_type kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            D::result_type d = (u[i] - mean);
-            D::result_type d2 = sqr(d);
+            D::result_type dbl = (u[i] - mean);
+            D::result_type d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -131,10 +131,10 @@ int main()
         D::result_type kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            D::result_type d = (u[i] - mean);
-            D::result_type d2 = sqr(d);
+            D::result_type dbl = (u[i] - mean);
+            D::result_type d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -171,10 +171,10 @@ int main()
         D::result_type kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            D::result_type d = (u[i] - mean);
-            D::result_type d2 = sqr(d);
+            D::result_type dbl = (u[i] - mean);
+            D::result_type d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -211,10 +211,10 @@ int main()
         D::result_type kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            D::result_type d = (u[i] - mean);
-            D::result_type d2 = sqr(d);
+            D::result_type dbl = (u[i] - mean);
+            D::result_type d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -251,10 +251,10 @@ int main()
         D::result_type kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            D::result_type d = (u[i] - mean);
-            D::result_type d2 = sqr(d);
+            D::result_type dbl = (u[i] - mean);
+            D::result_type d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -291,10 +291,10 @@ int main()
         D::result_type kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            D::result_type d = (u[i] - mean);
-            D::result_type d2 = sqr(d);
+            D::result_type dbl = (u[i] - mean);
+            D::result_type d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -331,10 +331,10 @@ int main()
         D::result_type kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            D::result_type d = (u[i] - mean);
-            D::result_type d2 = sqr(d);
+            D::result_type dbl = (u[i] - mean);
+            D::result_type d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -371,10 +371,10 @@ int main()
         D::result_type kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            D::result_type d = (u[i] - mean);
-            D::result_type d2 = sqr(d);
+            D::result_type dbl = (u[i] - mean);
+            D::result_type d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -411,10 +411,10 @@ int main()
         D::result_type kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            D::result_type d = (u[i] - mean);
-            D::result_type d2 = sqr(d);
+            D::result_type dbl = (u[i] - mean);
+            D::result_type d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
@@ -451,10 +451,10 @@ int main()
         D::result_type kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            D::result_type d = (u[i] - mean);
-            D::result_type d2 = sqr(d);
+            D::result_type dbl = (u[i] - mean);
+            D::result_type d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval_param.pass.cpp
index b5803f401465..d351f0caed71 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval_param.pass.cpp
@@ -51,10 +51,10 @@ int main()
         D::result_type kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            D::result_type d = (u[i] - mean);
-            D::result_type d2 = sqr(d);
+            D::result_type dbl = (u[i] - mean);
+            D::result_type d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
diff --git a/test/std/re/re.alg/re.alg.match/awk.pass.cpp b/test/std/re/re.alg/re.alg.match/awk.pass.cpp
index e4b2f3ec5014..a32b2ca0ae32 100644
--- a/test/std/re/re.alg/re.alg.match/awk.pass.cpp
+++ b/test/std/re/re.alg/re.alg.match/awk.pass.cpp
@@ -19,6 +19,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 #include "test_iterators.h"
 
 #include "platform_support.h" // locale name macros
diff --git a/test/std/re/re.alg/re.alg.match/basic.fail.cpp b/test/std/re/re.alg/re.alg.match/basic.fail.cpp
index 82f8e3b7ee89..04ce8fdd201b 100644
--- a/test/std/re/re.alg/re.alg.match/basic.fail.cpp
+++ b/test/std/re/re.alg/re.alg.match/basic.fail.cpp
@@ -9,21 +9,22 @@
 
 // <regex>
 
-//   template <class ST, class SA, class Allocator, class charT, class traits> 
-//   bool regex_match(const basic_string<charT, ST, SA>&&, 
+//   template <class ST, class SA, class Allocator, class charT, class traits>
+//   bool regex_match(const basic_string<charT, ST, SA>&&,
 //                    match_results<
-//                      typename basic_string<charT, ST, SA>::const_iterator, 
-//                      Allocator>&, 
-//                    const basic_regex<charT, traits>&, 
-//                    regex_constants::match_flag_type = 
+//                      typename basic_string<charT, ST, SA>::const_iterator,
+//                      Allocator>&,
+//                    const basic_regex<charT, traits>&,
+//                    regex_constants::match_flag_type =
 //                      regex_constants::match_default) = delete;
 
-#if __cplusplus <= 201402L
-#error
-#else
-
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
+
+#if TEST_STD_VER < 14
+#error
+#endif
 
 int main()
 {
@@ -33,4 +34,3 @@ int main()
         std::regex_match(std::string("abcde"), m, re);
     }
 }
-#endif
diff --git a/test/std/re/re.alg/re.alg.match/basic.pass.cpp b/test/std/re/re.alg/re.alg.match/basic.pass.cpp
index 2ddc07a2000f..901bf90e6386 100644
--- a/test/std/re/re.alg/re.alg.match/basic.pass.cpp
+++ b/test/std/re/re.alg/re.alg.match/basic.pass.cpp
@@ -23,6 +23,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 #include "test_iterators.h"
 
 #include "platform_support.h" // locale name macros
diff --git a/test/std/re/re.alg/re.alg.match/ecma.pass.cpp b/test/std/re/re.alg/re.alg.match/ecma.pass.cpp
index 785a61c47f11..a4568f60167c 100644
--- a/test/std/re/re.alg/re.alg.match/ecma.pass.cpp
+++ b/test/std/re/re.alg/re.alg.match/ecma.pass.cpp
@@ -23,6 +23,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 #include "test_iterators.h"
 
 #include "platform_support.h" // locale name macros
diff --git a/test/std/re/re.alg/re.alg.match/egrep.pass.cpp b/test/std/re/re.alg/re.alg.match/egrep.pass.cpp
index dd2e6038dc31..53cff850e2d4 100644
--- a/test/std/re/re.alg/re.alg.match/egrep.pass.cpp
+++ b/test/std/re/re.alg/re.alg.match/egrep.pass.cpp
@@ -19,6 +19,7 @@
 #include <regex>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 int main()
diff --git a/test/std/re/re.alg/re.alg.match/extended.pass.cpp b/test/std/re/re.alg/re.alg.match/extended.pass.cpp
index 9ca31d1814a6..5e08d0ac5fdb 100644
--- a/test/std/re/re.alg/re.alg.match/extended.pass.cpp
+++ b/test/std/re/re.alg/re.alg.match/extended.pass.cpp
@@ -23,6 +23,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 #include "test_iterators.h"
 
 #include "platform_support.h" // locale name macros
diff --git a/test/std/re/re.alg/re.alg.match/grep.pass.cpp b/test/std/re/re.alg/re.alg.match/grep.pass.cpp
index 2dc0966d6b8d..efd33cb11e03 100644
--- a/test/std/re/re.alg/re.alg.match/grep.pass.cpp
+++ b/test/std/re/re.alg/re.alg.match/grep.pass.cpp
@@ -19,6 +19,7 @@
 #include <regex>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 int main()
diff --git a/test/std/re/re.alg/re.alg.match/lookahead_capture.pass.cpp b/test/std/re/re.alg/re.alg.match/lookahead_capture.pass.cpp
index 949739b992cb..95f400ce88c9 100644
--- a/test/std/re/re.alg/re.alg.match/lookahead_capture.pass.cpp
+++ b/test/std/re/re.alg/re.alg.match/lookahead_capture.pass.cpp
@@ -16,12 +16,13 @@
 //                  const basic_regex<charT, traits>& e,
 //                  regex_constants::match_flag_type flags = regex_constants::match_default);
 
-// std::regex in ECMAScript mode should not ignore capture groups inside lookahead assertions. 
+// std::regex in ECMAScript mode should not ignore capture groups inside lookahead assertions.
 // For example, matching /(?=(a))(a)/ to "a" should yield two captures: \1 = "a", \2 = "a"
 
 #include <regex>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 int main()
diff --git a/test/std/re/re.alg/re.alg.match/parse_curly_brackets.pass.cpp b/test/std/re/re.alg/re.alg.match/parse_curly_brackets.pass.cpp
index 0b4c6948140e..59b2832c4580 100644
--- a/test/std/re/re.alg/re.alg.match/parse_curly_brackets.pass.cpp
+++ b/test/std/re/re.alg/re.alg.match/parse_curly_brackets.pass.cpp
@@ -21,6 +21,7 @@
 #include <string>
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 void
 test1()
diff --git a/test/std/re/re.alg/re.alg.replace/test1.pass.cpp b/test/std/re/re.alg/re.alg.replace/test1.pass.cpp
index 9fd84fdc1f6e..13cc8f2a0dd2 100644
--- a/test/std/re/re.alg/re.alg.replace/test1.pass.cpp
+++ b/test/std/re/re.alg/re.alg.replace/test1.pass.cpp
@@ -22,6 +22,7 @@
 #include <regex>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 int main()
diff --git a/test/std/re/re.alg/re.alg.replace/test2.pass.cpp b/test/std/re/re.alg/re.alg.replace/test2.pass.cpp
index 63a4ed56933d..679644f09b68 100644
--- a/test/std/re/re.alg/re.alg.replace/test2.pass.cpp
+++ b/test/std/re/re.alg/re.alg.replace/test2.pass.cpp
@@ -22,6 +22,7 @@
 #include <regex>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 int main()
diff --git a/test/std/re/re.alg/re.alg.replace/test3.pass.cpp b/test/std/re/re.alg/re.alg.replace/test3.pass.cpp
index d1167860646f..c8b8c649d1da 100644
--- a/test/std/re/re.alg/re.alg.replace/test3.pass.cpp
+++ b/test/std/re/re.alg/re.alg.replace/test3.pass.cpp
@@ -19,6 +19,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.alg/re.alg.replace/test4.pass.cpp b/test/std/re/re.alg/re.alg.replace/test4.pass.cpp
index fba1bc19546a..251eae8f6e20 100644
--- a/test/std/re/re.alg/re.alg.replace/test4.pass.cpp
+++ b/test/std/re/re.alg/re.alg.replace/test4.pass.cpp
@@ -18,6 +18,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.alg/re.alg.replace/test5.pass.cpp b/test/std/re/re.alg/re.alg.replace/test5.pass.cpp
index 7190e41d5228..53720d6f72ae 100644
--- a/test/std/re/re.alg/re.alg.replace/test5.pass.cpp
+++ b/test/std/re/re.alg/re.alg.replace/test5.pass.cpp
@@ -19,6 +19,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.alg/re.alg.replace/test6.pass.cpp b/test/std/re/re.alg/re.alg.replace/test6.pass.cpp
index b01780077303..a00ac75193d5 100644
--- a/test/std/re/re.alg/re.alg.replace/test6.pass.cpp
+++ b/test/std/re/re.alg/re.alg.replace/test6.pass.cpp
@@ -19,6 +19,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.alg/re.alg.search/awk.pass.cpp b/test/std/re/re.alg/re.alg.search/awk.pass.cpp
index 7fc1b3fcc233..05d1f59e147a 100644
--- a/test/std/re/re.alg/re.alg.search/awk.pass.cpp
+++ b/test/std/re/re.alg/re.alg.search/awk.pass.cpp
@@ -23,6 +23,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 #include "test_iterators.h"
 
 #include "platform_support.h" // locale name macros
diff --git a/test/std/re/re.alg/re.alg.search/backup.pass.cpp b/test/std/re/re.alg/re.alg.search/backup.pass.cpp
index 7da58608705b..f33b844bed9c 100644
--- a/test/std/re/re.alg/re.alg.search/backup.pass.cpp
+++ b/test/std/re/re.alg/re.alg.search/backup.pass.cpp
@@ -20,6 +20,7 @@
 #include <string>
 #include <list>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.alg/re.alg.search/basic.fail.cpp b/test/std/re/re.alg/re.alg.search/basic.fail.cpp
index 9ab6a21ad9dc..430b0a3aa4c3 100644
--- a/test/std/re/re.alg/re.alg.search/basic.fail.cpp
+++ b/test/std/re/re.alg/re.alg.search/basic.fail.cpp
@@ -9,21 +9,22 @@
 
 // <regex>
 
-//   template <class ST, class SA, class Allocator, class charT, class traits> 
-//   bool regex_search(const basic_string<charT, ST, SA>&&, 
+//   template <class ST, class SA, class Allocator, class charT, class traits>
+//   bool regex_search(const basic_string<charT, ST, SA>&&,
 //                     match_results<
-//                       typename basic_string<charT, ST, SA>::const_iterator, 
-//                       Allocator>&, 
-//                     const basic_regex<charT, traits>&, 
-//                     regex_constants::match_flag_type = 
+//                       typename basic_string<charT, ST, SA>::const_iterator,
+//                       Allocator>&,
+//                     const basic_regex<charT, traits>&,
+//                     regex_constants::match_flag_type =
 //                       regex_constants::match_default) = delete;
 
-#if __cplusplus <= 201402L
-#error
-#else
-
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
+
+#if TEST_STD_VER < 14
+#error
+#endif
 
 int main()
 {
@@ -33,4 +34,3 @@ int main()
         std::regex_search(std::string("abcde"), m, re);
     }
 }
-#endif
diff --git a/test/std/re/re.alg/re.alg.search/basic.pass.cpp b/test/std/re/re.alg/re.alg.search/basic.pass.cpp
index bdfcd9cc9bcd..f5157f563755 100644
--- a/test/std/re/re.alg/re.alg.search/basic.pass.cpp
+++ b/test/std/re/re.alg/re.alg.search/basic.pass.cpp
@@ -23,6 +23,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 #include "test_iterators.h"
 
 #include "platform_support.h" // locale name macros
diff --git a/test/std/re/re.alg/re.alg.search/ecma.pass.cpp b/test/std/re/re.alg/re.alg.search/ecma.pass.cpp
index fb9fc26a281a..d6a3da6ea076 100644
--- a/test/std/re/re.alg/re.alg.search/ecma.pass.cpp
+++ b/test/std/re/re.alg/re.alg.search/ecma.pass.cpp
@@ -23,6 +23,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 #include "test_iterators.h"
 
 #include "platform_support.h" // locale name macros
diff --git a/test/std/re/re.alg/re.alg.search/egrep.pass.cpp b/test/std/re/re.alg/re.alg.search/egrep.pass.cpp
index 1dffed44f227..0bf8386119ee 100644
--- a/test/std/re/re.alg/re.alg.search/egrep.pass.cpp
+++ b/test/std/re/re.alg/re.alg.search/egrep.pass.cpp
@@ -19,6 +19,7 @@
 #include <regex>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 int main()
diff --git a/test/std/re/re.alg/re.alg.search/extended.pass.cpp b/test/std/re/re.alg/re.alg.search/extended.pass.cpp
index 81eef2f9e4b9..88af3b908815 100644
--- a/test/std/re/re.alg/re.alg.search/extended.pass.cpp
+++ b/test/std/re/re.alg/re.alg.search/extended.pass.cpp
@@ -23,6 +23,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 #include "test_iterators.h"
 
 #include "platform_support.h" // locale name macros
diff --git a/test/std/re/re.alg/re.alg.search/grep.pass.cpp b/test/std/re/re.alg/re.alg.search/grep.pass.cpp
index 9d74c2417d2d..136f9958c9b2 100644
--- a/test/std/re/re.alg/re.alg.search/grep.pass.cpp
+++ b/test/std/re/re.alg/re.alg.search/grep.pass.cpp
@@ -34,9 +34,9 @@ extern "C" void LLVMFuzzerTestOneInput(const char *data)
             std::string s((const char *)data, size);
             std::regex re(s, flag);
             std::regex_match(s, re);
-        } 
-        catch (std::regex_error &ex) {} 
-    } 
+        }
+        catch (std::regex_error &) {}
+    }
 }
 
 
diff --git a/test/std/re/re.alg/re.alg.search/lookahead.pass.cpp b/test/std/re/re.alg/re.alg.search/lookahead.pass.cpp
index 9f5f9540165a..93424e188432 100644
--- a/test/std/re/re.alg/re.alg.search/lookahead.pass.cpp
+++ b/test/std/re/re.alg/re.alg.search/lookahead.pass.cpp
@@ -20,8 +20,9 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
-int main() 
+int main()
 {
     assert(!std::regex_search("ab", std::regex("(?=^)b")));
     assert(!std::regex_search("ab", std::regex("a(?=^)b")));
diff --git a/test/std/re/re.alg/re.alg.search/no_update_pos.pass.cpp b/test/std/re/re.alg/re.alg.search/no_update_pos.pass.cpp
index ef9cec5f736e..600425d8de35 100644
--- a/test/std/re/re.alg/re.alg.search/no_update_pos.pass.cpp
+++ b/test/std/re/re.alg/re.alg.search/no_update_pos.pass.cpp
@@ -18,6 +18,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.badexp/regex_error.pass.cpp b/test/std/re/re.badexp/regex_error.pass.cpp
index 02fecbda2d95..f1752716ec75 100644
--- a/test/std/re/re.badexp/regex_error.pass.cpp
+++ b/test/std/re/re.badexp/regex_error.pass.cpp
@@ -20,6 +20,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.const/re.err/error_type.pass.cpp b/test/std/re/re.const/re.err/error_type.pass.cpp
index 150855beb0a4..3609d41b9beb 100644
--- a/test/std/re/re.const/re.err/error_type.pass.cpp
+++ b/test/std/re/re.const/re.err/error_type.pass.cpp
@@ -34,6 +34,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.const/re.matchflag/match_flag_type.pass.cpp b/test/std/re/re.const/re.matchflag/match_flag_type.pass.cpp
index b48703c7579f..c7b2a80cd2a4 100644
--- a/test/std/re/re.const/re.matchflag/match_flag_type.pass.cpp
+++ b/test/std/re/re.const/re.matchflag/match_flag_type.pass.cpp
@@ -34,6 +34,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.const/re.matchflag/match_not_bol.pass.cpp b/test/std/re/re.const/re.matchflag/match_not_bol.pass.cpp
index 41ac0cee0d6a..03e8770dd68d 100644
--- a/test/std/re/re.const/re.matchflag/match_not_bol.pass.cpp
+++ b/test/std/re/re.const/re.matchflag/match_not_bol.pass.cpp
@@ -11,12 +11,13 @@
 // <regex>
 
 // match_not_bol:
-//     The first character in the sequence [first,last) shall be treated as 
-//     though it is not at the beginning of a line, so the character ^ in the 
+//     The first character in the sequence [first,last) shall be treated as
+//     though it is not at the beginning of a line, so the character ^ in the
 //     regular expression shall not match [first,first).
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.const/re.matchflag/match_not_eol.pass.cpp b/test/std/re/re.const/re.matchflag/match_not_eol.pass.cpp
index 594c9fb98453..1c9b154f1fcc 100644
--- a/test/std/re/re.const/re.matchflag/match_not_eol.pass.cpp
+++ b/test/std/re/re.const/re.matchflag/match_not_eol.pass.cpp
@@ -11,12 +11,13 @@
 // <regex>
 
 // match_not_eol:
-//     The last character in the sequence [first,last) shall be treated as 
-//     though it is not at the end of a line, so the character "$" in 
+//     The last character in the sequence [first,last) shall be treated as
+//     though it is not at the end of a line, so the character "$" in
 //     the regular expression shall not match [last,last).
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.const/re.synopt/syntax_option_type.pass.cpp b/test/std/re/re.const/re.synopt/syntax_option_type.pass.cpp
index 1c4f824448a6..ad6111cc4ee2 100644
--- a/test/std/re/re.const/re.synopt/syntax_option_type.pass.cpp
+++ b/test/std/re/re.const/re.synopt/syntax_option_type.pass.cpp
@@ -31,6 +31,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.fail.cpp b/test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.fail.cpp
index 208de0e43cec..24fb3787ed1f 100644
--- a/test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.fail.cpp
+++ b/test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.fail.cpp
@@ -17,20 +17,20 @@
 //                      regex_constants::match_flag_type m =
 //                        regex_constants::match_default) = delete;
 
-#if __cplusplus <= 201402L
-#error
-#else
-
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
+
+#if TEST_STD_VER < 14
+#error
+#endif
 
 int main()
 {
     {
         const char phone_book[] = "555-1234, 555-2345, 555-3456";
         std::cregex_iterator i(
-            std::begin(phone_book), std::end(phone_book), 
+            std::begin(phone_book), std::end(phone_book),
             std::regex("\\d{3}-\\d{4}"));
     }
 }
-#endif
diff --git a/test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.pass.cpp b/test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.pass.cpp
index c9fc7a3cd1cc..c1cabff39d54 100644
--- a/test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.pass.cpp
+++ b/test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.pass.cpp
@@ -17,6 +17,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.iter/re.regiter/re.regiter.cnstr/default.pass.cpp b/test/std/re/re.iter/re.regiter/re.regiter.cnstr/default.pass.cpp
index 9d4766dc876f..cb44fb37bc89 100644
--- a/test/std/re/re.iter/re.regiter/re.regiter.cnstr/default.pass.cpp
+++ b/test/std/re/re.iter/re.regiter/re.regiter.cnstr/default.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 template <class CharT>
 void
diff --git a/test/std/re/re.iter/re.regiter/re.regiter.deref/deref.pass.cpp b/test/std/re/re.iter/re.regiter/re.regiter.deref/deref.pass.cpp
index e4933fe16f8e..800f56434160 100644
--- a/test/std/re/re.iter/re.regiter/re.regiter.deref/deref.pass.cpp
+++ b/test/std/re/re.iter/re.regiter/re.regiter.deref/deref.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.iter/re.regiter/re.regiter.incr/post.pass.cpp b/test/std/re/re.iter/re.regiter/re.regiter.incr/post.pass.cpp
index 3ec0d6c0c3b4..f3b57f6bc9da 100644
--- a/test/std/re/re.iter/re.regiter/re.regiter.incr/post.pass.cpp
+++ b/test/std/re/re.iter/re.regiter/re.regiter.incr/post.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.iter/re.regiter/types.pass.cpp b/test/std/re/re.iter/re.regiter/types.pass.cpp
index db1d3eb958bf..5b79957bea24 100644
--- a/test/std/re/re.iter/re.regiter/types.pass.cpp
+++ b/test/std/re/re.iter/re.regiter/types.pass.cpp
@@ -24,6 +24,7 @@
 
 #include <regex>
 #include <type_traits>
+#include "test_macros.h"
 
 template <class CharT>
 void
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.fail.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.fail.cpp
index 6753b0ad506b..8f90b23907dc 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.fail.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.fail.cpp
@@ -18,13 +18,14 @@
 //                      regex_constants::match_flag_type m =
 //                                              regex_constants::match_default);
 
-#if __cplusplus <= 201402L
-#error
-#else
-
 #include <regex>
 #include <vector>
 #include <cassert>
+#include "test_macros.h"
+
+#if TEST_STD_VER < 14
+#error
+#endif
 
 int main()
 {
@@ -36,4 +37,3 @@ int main()
                                      std::regex("\\d{3}-\\d{4}"), indices);
     }
 }
-#endif
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.pass.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.pass.cpp
index a51b8274bdd8..6d8c2f35e424 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.pass.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.pass.cpp
@@ -20,6 +20,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/default.pass.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/default.pass.cpp
index 382815e0c1cc..e71f3a69217e 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/default.pass.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/default.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 template <class CharT>
 void
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.fail.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.fail.cpp
index e58183682ea4..9d538730e809 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.fail.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.fail.cpp
@@ -17,12 +17,13 @@
 //                      regex_constants::match_flag_type m =
 //                                              regex_constants::match_default);
 
-#if __cplusplus <= 201402L
-#error
-#else
-
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
+
+#if TEST_STD_VER < 14
+#error
+#endif
 
 int main()
 {
@@ -33,4 +34,3 @@ int main()
                                       std::regex("\\d{3}-\\d{4}"), {-1, 0, 1});
     }
 }
-#endif
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.pass.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.pass.cpp
index b40d7eb9224d..6cffc0da9a52 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.pass.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.pass.cpp
@@ -19,6 +19,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.fail.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.fail.cpp
index d0a100a1afcc..f4601f3ed033 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.fail.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.fail.cpp
@@ -16,12 +16,13 @@
 //                      regex_constants::match_flag_type m =
 //                                              regex_constants::match_default);
 
-#if __cplusplus <= 201402L
-#error
-#else
-
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
+
+#if TEST_STD_VER < 14
+#error
+#endif
 
 int main()
 {
@@ -32,4 +33,3 @@ int main()
                                      std::regex("\\d{3}-\\d{4}"), -1);
     }
 }
-#endif
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.pass.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.pass.cpp
index d8111363c176..37fe2d9767ef 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.pass.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.pass.cpp
@@ -18,6 +18,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.fail.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.fail.cpp
index 94d8f9667d2c..d5d5f4c63ceb 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.fail.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.fail.cpp
@@ -18,12 +18,13 @@
 //                      regex_constants::match_flag_type m =
 //                                              regex_constants::match_default);
 
-#if __cplusplus <= 201402L
-#error
-#else
-
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
+
+#if TEST_STD_VER < 14
+#error
+#endif
 
 int main()
 {
@@ -37,4 +38,3 @@ int main()
                                      std::regex("\\d{3}-\\d{4}"), v);
     }
 }
-#endif
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.pass.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.pass.cpp
index b04f5804509f..473a706dd854 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.pass.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.pass.cpp
@@ -19,6 +19,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.comp/equal.pass.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.comp/equal.pass.cpp
index d6399f1148b4..49d1b1b7ed54 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.comp/equal.pass.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.comp/equal.pass.cpp
@@ -16,6 +16,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.deref/deref.pass.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.deref/deref.pass.cpp
index b096e3c08275..73ec62cfc67d 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.deref/deref.pass.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.deref/deref.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.incr/post.pass.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.incr/post.pass.cpp
index 727ab7af9376..7d55bc1113fa 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.incr/post.pass.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.incr/post.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.iter/re.tokiter/types.pass.cpp b/test/std/re/re.iter/re.tokiter/types.pass.cpp
index 89287bdd1d00..b7777fbeefff 100644
--- a/test/std/re/re.iter/re.tokiter/types.pass.cpp
+++ b/test/std/re/re.iter/re.tokiter/types.pass.cpp
@@ -24,6 +24,7 @@
 
 #include <regex>
 #include <type_traits>
+#include "test_macros.h"
 
 template <class CharT>
 void
diff --git a/test/std/re/re.regex/re.regex.assign/assign.il.pass.cpp b/test/std/re/re.regex/re.regex.assign/assign.il.pass.cpp
index 96cadf166001..39c3a22ef725 100644
--- a/test/std/re/re.regex/re.regex.assign/assign.il.pass.cpp
+++ b/test/std/re/re.regex/re.regex.assign/assign.il.pass.cpp
@@ -17,6 +17,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.regex/re.regex.assign/assign.pass.cpp b/test/std/re/re.regex/re.regex.assign/assign.pass.cpp
index 9c5f834b9452..97208c68c8d6 100644
--- a/test/std/re/re.regex/re.regex.assign/assign.pass.cpp
+++ b/test/std/re/re.regex/re.regex.assign/assign.pass.cpp
@@ -16,6 +16,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
@@ -25,7 +26,7 @@ int main()
     assert(r2.flags() == std::regex::ECMAScript);
     assert(r2.mark_count() == 2);
     assert(std::regex_search("ab", r2));
-    
+
     bool caught = false;
     try { r2.assign("(def", std::regex::extended); }
     catch(std::regex_error &) { caught = true; }
diff --git a/test/std/re/re.regex/re.regex.assign/assign_iter_iter_flag.pass.cpp b/test/std/re/re.regex/re.regex.assign/assign_iter_iter_flag.pass.cpp
index 529a64a239a0..7cd4845f3073 100644
--- a/test/std/re/re.regex/re.regex.assign/assign_iter_iter_flag.pass.cpp
+++ b/test/std/re/re.regex/re.regex.assign/assign_iter_iter_flag.pass.cpp
@@ -19,6 +19,7 @@
 #include <regex>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 int main()
diff --git a/test/std/re/re.regex/re.regex.assign/assign_ptr_flag.pass.cpp b/test/std/re/re.regex/re.regex.assign/assign_ptr_flag.pass.cpp
index dd39dee13ffb..33b9cad18335 100644
--- a/test/std/re/re.regex/re.regex.assign/assign_ptr_flag.pass.cpp
+++ b/test/std/re/re.regex/re.regex.assign/assign_ptr_flag.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.regex/re.regex.assign/assign_ptr_size_flag.pass.cpp b/test/std/re/re.regex/re.regex.assign/assign_ptr_size_flag.pass.cpp
index 679cd9df17fc..7ec4f77a5052 100644
--- a/test/std/re/re.regex/re.regex.assign/assign_ptr_size_flag.pass.cpp
+++ b/test/std/re/re.regex/re.regex.assign/assign_ptr_size_flag.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.regex/re.regex.assign/assign_string_flag.pass.cpp b/test/std/re/re.regex/re.regex.assign/assign_string_flag.pass.cpp
index 46f984da04db..247d27721be7 100644
--- a/test/std/re/re.regex/re.regex.assign/assign_string_flag.pass.cpp
+++ b/test/std/re/re.regex/re.regex.assign/assign_string_flag.pass.cpp
@@ -17,6 +17,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.regex/re.regex.assign/copy.pass.cpp b/test/std/re/re.regex/re.regex.assign/copy.pass.cpp
index 2a616ff012c1..3f212f772a38 100644
--- a/test/std/re/re.regex/re.regex.assign/copy.pass.cpp
+++ b/test/std/re/re.regex/re.regex.assign/copy.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.regex/re.regex.assign/il.pass.cpp b/test/std/re/re.regex/re.regex.assign/il.pass.cpp
index a9d8ada4ff0e..022170f2d136 100644
--- a/test/std/re/re.regex/re.regex.assign/il.pass.cpp
+++ b/test/std/re/re.regex/re.regex.assign/il.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.regex/re.regex.assign/ptr.pass.cpp b/test/std/re/re.regex/re.regex.assign/ptr.pass.cpp
index 4c42f822a1e5..d2af1f9b3d1a 100644
--- a/test/std/re/re.regex/re.regex.assign/ptr.pass.cpp
+++ b/test/std/re/re.regex/re.regex.assign/ptr.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.regex/re.regex.assign/string.pass.cpp b/test/std/re/re.regex/re.regex.assign/string.pass.cpp
index 7f09e5364ac4..65cc4a345ed8 100644
--- a/test/std/re/re.regex/re.regex.assign/string.pass.cpp
+++ b/test/std/re/re.regex/re.regex.assign/string.pass.cpp
@@ -16,6 +16,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.regex/re.regex.const/constants.pass.cpp b/test/std/re/re.regex/re.regex.const/constants.pass.cpp
index 85297b91f433..e699de819b0d 100644
--- a/test/std/re/re.regex/re.regex.const/constants.pass.cpp
+++ b/test/std/re/re.regex/re.regex.const/constants.pass.cpp
@@ -27,6 +27,7 @@
 
 #include <regex>
 #include <type_traits>
+#include "test_macros.h"
 
 template <class _Tp>
 void where(const _Tp &) {}
diff --git a/test/std/re/re.regex/re.regex.construct/awk_oct.pass.cpp b/test/std/re/re.regex/re.regex.construct/awk_oct.pass.cpp
index 4b7e5e629294..3f1eaf6b959e 100644
--- a/test/std/re/re.regex/re.regex.construct/awk_oct.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/awk_oct.pass.cpp
@@ -16,13 +16,14 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
-int main() 
+int main()
 {
     using std::regex_constants::awk;
 
     assert(std::regex_match("\4", std::regex("\\4", awk)));
     assert(std::regex_match("\41", std::regex("\\41", awk)));
     assert(std::regex_match("\141", std::regex("\\141", awk)));
-    assert(std::regex_match("\1411", std::regex("\\1411", awk)));
+    assert(std::regex_match("\141" "1", std::regex("\\1411", awk)));
 }
diff --git a/test/std/re/re.regex/re.regex.construct/bad_escape.pass.cpp b/test/std/re/re.regex/re.regex.construct/bad_escape.pass.cpp
index 9459cd74ccff..3c7e9f5e33c7 100644
--- a/test/std/re/re.regex/re.regex.construct/bad_escape.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/bad_escape.pass.cpp
@@ -17,8 +17,9 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
-static bool error_escape_thrown(const char *pat) 
+static bool error_escape_thrown(const char *pat)
 {
     bool result = false;
     try {
@@ -29,7 +30,7 @@ static bool error_escape_thrown(const char *pat)
     return result;
 }
 
-int main() 
+int main()
 {
     assert(error_escape_thrown("[\\a]"));
     assert(error_escape_thrown("\\a"));
diff --git a/test/std/re/re.regex/re.regex.construct/bad_repeat.pass.cpp b/test/std/re/re.regex/re.regex.construct/bad_repeat.pass.cpp
index c21672f02c98..0692a59542f6 100644
--- a/test/std/re/re.regex/re.regex.construct/bad_repeat.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/bad_repeat.pass.cpp
@@ -17,8 +17,9 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
-static bool error_badrepeat_thrown(const char *pat) 
+static bool error_badrepeat_thrown(const char *pat)
 {
     bool result = false;
     try {
@@ -29,7 +30,7 @@ static bool error_badrepeat_thrown(const char *pat)
     return result;
 }
 
-int main() 
+int main()
 {
     assert(error_badrepeat_thrown("?a"));
     assert(error_badrepeat_thrown("*a"));
diff --git a/test/std/re/re.regex/re.regex.construct/copy.pass.cpp b/test/std/re/re.regex/re.regex.construct/copy.pass.cpp
index c2788f0fa2c6..a266289c6a88 100644
--- a/test/std/re/re.regex/re.regex.construct/copy.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/copy.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.regex/re.regex.construct/default.pass.cpp b/test/std/re/re.regex/re.regex.construct/default.pass.cpp
index d959c1ec5820..f1d7bf7696d9 100644
--- a/test/std/re/re.regex/re.regex.construct/default.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/default.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 template <class CharT>
 void
diff --git a/test/std/re/re.regex/re.regex.construct/il_flg.pass.cpp b/test/std/re/re.regex/re.regex.construct/il_flg.pass.cpp
index 70d28df370d1..c1554d6c3ebb 100644
--- a/test/std/re/re.regex/re.regex.construct/il_flg.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/il_flg.pass.cpp
@@ -16,6 +16,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
diff --git a/test/std/re/re.regex/re.regex.construct/iter_iter.pass.cpp b/test/std/re/re.regex/re.regex.construct/iter_iter.pass.cpp
index a38e16234191..4a93d173e6fc 100644
--- a/test/std/re/re.regex/re.regex.construct/iter_iter.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/iter_iter.pass.cpp
@@ -18,6 +18,7 @@
 #include <cassert>
 
 #include "test_iterators.h"
+#include "test_macros.h"
 
 template <class Iter>
 void
diff --git a/test/std/re/re.regex/re.regex.construct/iter_iter_flg.pass.cpp b/test/std/re/re.regex/re.regex.construct/iter_iter_flg.pass.cpp
index c4c440e6d246..347989c5de15 100644
--- a/test/std/re/re.regex/re.regex.construct/iter_iter_flg.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/iter_iter_flg.pass.cpp
@@ -19,6 +19,7 @@
 #include <cassert>
 
 #include "test_iterators.h"
+#include "test_macros.h"
 
 template <class Iter>
 void
diff --git a/test/std/re/re.regex/re.regex.construct/ptr.pass.cpp b/test/std/re/re.regex/re.regex.construct/ptr.pass.cpp
index b99b58b469cf..05fba020566b 100644
--- a/test/std/re/re.regex/re.regex.construct/ptr.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/ptr.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 template <class CharT>
 void
diff --git a/test/std/re/re.regex/re.regex.construct/ptr_flg.pass.cpp b/test/std/re/re.regex/re.regex.construct/ptr_flg.pass.cpp
index 138e20efbf65..d37b81592b4e 100644
--- a/test/std/re/re.regex/re.regex.construct/ptr_flg.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/ptr_flg.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 template <class CharT>
 void
diff --git a/test/std/re/re.regex/re.regex.construct/ptr_size_flg.pass.cpp b/test/std/re/re.regex/re.regex.construct/ptr_size_flg.pass.cpp
index d623a15936f4..a0ceb70514bf 100644
--- a/test/std/re/re.regex/re.regex.construct/ptr_size_flg.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/ptr_size_flg.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 template <class CharT>
 void
diff --git a/test/std/re/re.regex/re.regex.construct/string.pass.cpp b/test/std/re/re.regex/re.regex.construct/string.pass.cpp
index b58b8e03cd20..a8f2e9bf6c20 100644
--- a/test/std/re/re.regex/re.regex.construct/string.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/string.pass.cpp
@@ -16,6 +16,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 template <class String>
 void
diff --git a/test/std/re/re.regex/re.regex.construct/string_flg.pass.cpp b/test/std/re/re.regex/re.regex.construct/string_flg.pass.cpp
index 768de568e229..5f87af10224a 100644
--- a/test/std/re/re.regex/re.regex.construct/string_flg.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/string_flg.pass.cpp
@@ -17,6 +17,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 template <class String>
 void
diff --git a/test/std/re/re.regex/re.regex.locale/imbue.pass.cpp b/test/std/re/re.regex/re.regex.locale/imbue.pass.cpp
index c7ad39414c65..85900488f235 100644
--- a/test/std/re/re.regex/re.regex.locale/imbue.pass.cpp
+++ b/test/std/re/re.regex/re.regex.locale/imbue.pass.cpp
@@ -19,6 +19,7 @@
 #include <locale>
 #include <cassert>
 
+#include "test_macros.h"
 #include "platform_support.h" // locale name macros
 
 int main()
diff --git a/test/std/re/re.regex/re.regex.nonmemb/re.regex.nmswap/swap.pass.cpp b/test/std/re/re.regex/re.regex.nonmemb/re.regex.nmswap/swap.pass.cpp
index 9d3c481686e7..7b231726557d 100644
--- a/test/std/re/re.regex/re.regex.nonmemb/re.regex.nmswap/swap.pass.cpp
+++ b/test/std/re/re.regex/re.regex.nonmemb/re.regex.nmswap/swap.pass.cpp
@@ -16,6 +16,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.regex/re.regex.swap/swap.pass.cpp b/test/std/re/re.regex/re.regex.swap/swap.pass.cpp
index cda8ef3541a2..a04c64d4a471 100644
--- a/test/std/re/re.regex/re.regex.swap/swap.pass.cpp
+++ b/test/std/re/re.regex/re.regex.swap/swap.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.regex/types.pass.cpp b/test/std/re/re.regex/types.pass.cpp
index 02011ac56ebb..5c0a5920d201 100644
--- a/test/std/re/re.regex/types.pass.cpp
+++ b/test/std/re/re.regex/types.pass.cpp
@@ -20,6 +20,7 @@
 
 #include <regex>
 #include <type_traits>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.results/re.results.acc/begin_end.pass.cpp b/test/std/re/re.results/re.results.acc/begin_end.pass.cpp
index 80c06f299bd7..a5ed051265cc 100644
--- a/test/std/re/re.results/re.results.acc/begin_end.pass.cpp
+++ b/test/std/re/re.results/re.results.acc/begin_end.pass.cpp
@@ -16,6 +16,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 void
 test()
diff --git a/test/std/re/re.results/re.results.acc/cbegin_cend.pass.cpp b/test/std/re/re.results/re.results.acc/cbegin_cend.pass.cpp
index a983c8afc81a..67ec606e9060 100644
--- a/test/std/re/re.results/re.results.acc/cbegin_cend.pass.cpp
+++ b/test/std/re/re.results/re.results.acc/cbegin_cend.pass.cpp
@@ -16,6 +16,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 void
 test()
diff --git a/test/std/re/re.results/re.results.acc/index.pass.cpp b/test/std/re/re.results/re.results.acc/index.pass.cpp
index 79d4b9a23788..8118d3c9c300 100644
--- a/test/std/re/re.results/re.results.acc/index.pass.cpp
+++ b/test/std/re/re.results/re.results.acc/index.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 void
 test(std::regex_constants::syntax_option_type syntax)
diff --git a/test/std/re/re.results/re.results.acc/length.pass.cpp b/test/std/re/re.results/re.results.acc/length.pass.cpp
index 91020851a308..7bf689c5b790 100644
--- a/test/std/re/re.results/re.results.acc/length.pass.cpp
+++ b/test/std/re/re.results/re.results.acc/length.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 void
 test()
diff --git a/test/std/re/re.results/re.results.acc/position.pass.cpp b/test/std/re/re.results/re.results.acc/position.pass.cpp
index 2698e2d91693..b7df2c7c21c9 100644
--- a/test/std/re/re.results/re.results.acc/position.pass.cpp
+++ b/test/std/re/re.results/re.results.acc/position.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 void
 test()
diff --git a/test/std/re/re.results/re.results.acc/prefix.pass.cpp b/test/std/re/re.results/re.results.acc/prefix.pass.cpp
index 58cdabc24df8..0c8572a0d713 100644
--- a/test/std/re/re.results/re.results.acc/prefix.pass.cpp
+++ b/test/std/re/re.results/re.results.acc/prefix.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 void
 test()
diff --git a/test/std/re/re.results/re.results.acc/str.pass.cpp b/test/std/re/re.results/re.results.acc/str.pass.cpp
index 2ebfeabb2078..512bd9e69a88 100644
--- a/test/std/re/re.results/re.results.acc/str.pass.cpp
+++ b/test/std/re/re.results/re.results.acc/str.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 void
 test()
diff --git a/test/std/re/re.results/re.results.acc/suffix.pass.cpp b/test/std/re/re.results/re.results.acc/suffix.pass.cpp
index b842ea861e43..a78bb67b4f0d 100644
--- a/test/std/re/re.results/re.results.acc/suffix.pass.cpp
+++ b/test/std/re/re.results/re.results.acc/suffix.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 void
 test()
diff --git a/test/std/re/re.results/re.results.all/get_allocator.pass.cpp b/test/std/re/re.results/re.results.all/get_allocator.pass.cpp
index 04367953ad29..c4fe96d4a8a9 100644
--- a/test/std/re/re.results/re.results.all/get_allocator.pass.cpp
+++ b/test/std/re/re.results/re.results.all/get_allocator.pass.cpp
@@ -16,6 +16,7 @@
 #include <regex>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_allocator.h"
 
 template <class CharT, class Allocator>
diff --git a/test/std/re/re.results/re.results.const/allocator.pass.cpp b/test/std/re/re.results/re.results.const/allocator.pass.cpp
index a24c669f657d..73347d08c694 100644
--- a/test/std/re/re.results/re.results.const/allocator.pass.cpp
+++ b/test/std/re/re.results/re.results.const/allocator.pass.cpp
@@ -16,6 +16,7 @@
 #include <regex>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_allocator.h"
 
 template <class CharT, class Allocator>
diff --git a/test/std/re/re.results/re.results.const/default.pass.cpp b/test/std/re/re.results/re.results.const/default.pass.cpp
index e10fbfd76cf0..2fa85533a0ae 100644
--- a/test/std/re/re.results/re.results.const/default.pass.cpp
+++ b/test/std/re/re.results/re.results.const/default.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 template <class CharT>
 void
diff --git a/test/std/re/re.results/re.results.form/form1.pass.cpp b/test/std/re/re.results/re.results.form/form1.pass.cpp
index 5b04c684fef1..55b5ade790a5 100644
--- a/test/std/re/re.results/re.results.form/form1.pass.cpp
+++ b/test/std/re/re.results/re.results.form/form1.pass.cpp
@@ -19,6 +19,7 @@
 #include <regex>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 int main()
diff --git a/test/std/re/re.results/re.results.form/form2.pass.cpp b/test/std/re/re.results/re.results.form/form2.pass.cpp
index b18b7fb9f555..ab7a525f4893 100644
--- a/test/std/re/re.results/re.results.form/form2.pass.cpp
+++ b/test/std/re/re.results/re.results.form/form2.pass.cpp
@@ -21,6 +21,7 @@
 #include <regex>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 #include "test_allocator.h"
 
diff --git a/test/std/re/re.results/re.results.form/form3.pass.cpp b/test/std/re/re.results/re.results.form/form3.pass.cpp
index 27f2388adce0..e4c2e3d20283 100644
--- a/test/std/re/re.results/re.results.form/form3.pass.cpp
+++ b/test/std/re/re.results/re.results.form/form3.pass.cpp
@@ -21,6 +21,7 @@
 #include <regex>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_allocator.h"
 
 int main()
diff --git a/test/std/re/re.results/re.results.form/form4.pass.cpp b/test/std/re/re.results/re.results.form/form4.pass.cpp
index 1d44c32f6a8b..2c8aa9b8f9b5 100644
--- a/test/std/re/re.results/re.results.form/form4.pass.cpp
+++ b/test/std/re/re.results/re.results.form/form4.pass.cpp
@@ -19,6 +19,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.results/re.results.nonmember/equal.pass.cpp b/test/std/re/re.results/re.results.nonmember/equal.pass.cpp
index 7902b8e642e4..0a32f2e258a9 100644
--- a/test/std/re/re.results/re.results.nonmember/equal.pass.cpp
+++ b/test/std/re/re.results/re.results.nonmember/equal.pass.cpp
@@ -23,6 +23,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 void
 test()
diff --git a/test/std/re/re.results/re.results.size/empty.pass.cpp b/test/std/re/re.results/re.results.size/empty.pass.cpp
index 6634d92830dc..f03f5f752b3d 100644
--- a/test/std/re/re.results/re.results.size/empty.pass.cpp
+++ b/test/std/re/re.results/re.results.size/empty.pass.cpp
@@ -16,6 +16,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 template <class CharT>
 void
diff --git a/test/std/re/re.results/re.results.size/max_size.pass.cpp b/test/std/re/re.results/re.results.size/max_size.pass.cpp
index 0b31409275bf..1ba29b926d5e 100644
--- a/test/std/re/re.results/re.results.size/max_size.pass.cpp
+++ b/test/std/re/re.results/re.results.size/max_size.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 template <class CharT>
 void
diff --git a/test/std/re/re.results/re.results.state/ready.pass.cpp b/test/std/re/re.results/re.results.state/ready.pass.cpp
index 8f586c3f32d6..1348016bbd91 100644
--- a/test/std/re/re.results/re.results.state/ready.pass.cpp
+++ b/test/std/re/re.results/re.results.state/ready.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 void
 test1()
diff --git a/test/std/re/re.results/re.results.swap/member_swap.pass.cpp b/test/std/re/re.results/re.results.swap/member_swap.pass.cpp
index 09b85c0ff5d2..cd1d72a2d4d1 100644
--- a/test/std/re/re.results/re.results.swap/member_swap.pass.cpp
+++ b/test/std/re/re.results/re.results.swap/member_swap.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 void
 test()
diff --git a/test/std/re/re.results/re.results.swap/non_member_swap.pass.cpp b/test/std/re/re.results/re.results.swap/non_member_swap.pass.cpp
index 3f5e34df44c5..81e6c819e54c 100644
--- a/test/std/re/re.results/re.results.swap/non_member_swap.pass.cpp
+++ b/test/std/re/re.results/re.results.swap/non_member_swap.pass.cpp
@@ -17,6 +17,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 void
 test()
diff --git a/test/std/re/re.results/types.pass.cpp b/test/std/re/re.results/types.pass.cpp
index 4d553837efe8..0b76875feaee 100644
--- a/test/std/re/re.results/types.pass.cpp
+++ b/test/std/re/re.results/types.pass.cpp
@@ -27,6 +27,7 @@
 
 #include <regex>
 #include <type_traits>
+#include "test_macros.h"
 
 template <class CharT>
 void
diff --git a/test/std/re/re.submatch/re.submatch.members/compare_string_type.pass.cpp b/test/std/re/re.submatch/re.submatch.members/compare_string_type.pass.cpp
index c14d5bcdefae..be05afd4cf88 100644
--- a/test/std/re/re.submatch/re.submatch.members/compare_string_type.pass.cpp
+++ b/test/std/re/re.submatch/re.submatch.members/compare_string_type.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.submatch/re.submatch.members/compare_sub_match.pass.cpp b/test/std/re/re.submatch/re.submatch.members/compare_sub_match.pass.cpp
index 0874742f1c9a..4b74f65d7826 100644
--- a/test/std/re/re.submatch/re.submatch.members/compare_sub_match.pass.cpp
+++ b/test/std/re/re.submatch/re.submatch.members/compare_sub_match.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.submatch/re.submatch.members/compare_value_type_ptr.pass.cpp b/test/std/re/re.submatch/re.submatch.members/compare_value_type_ptr.pass.cpp
index 48c05ca91d05..097a3918ed13 100644
--- a/test/std/re/re.submatch/re.submatch.members/compare_value_type_ptr.pass.cpp
+++ b/test/std/re/re.submatch/re.submatch.members/compare_value_type_ptr.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.submatch/re.submatch.members/default.pass.cpp b/test/std/re/re.submatch/re.submatch.members/default.pass.cpp
index 451466af83cd..1805f7eb3001 100644
--- a/test/std/re/re.submatch/re.submatch.members/default.pass.cpp
+++ b/test/std/re/re.submatch/re.submatch.members/default.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.submatch/re.submatch.members/length.pass.cpp b/test/std/re/re.submatch/re.submatch.members/length.pass.cpp
index 4874c0d05921..20095483d80b 100644
--- a/test/std/re/re.submatch/re.submatch.members/length.pass.cpp
+++ b/test/std/re/re.submatch/re.submatch.members/length.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.submatch/re.submatch.members/operator_string.pass.cpp b/test/std/re/re.submatch/re.submatch.members/operator_string.pass.cpp
index dd856a56d0b0..4c2877cd4db0 100644
--- a/test/std/re/re.submatch/re.submatch.members/operator_string.pass.cpp
+++ b/test/std/re/re.submatch/re.submatch.members/operator_string.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.submatch/re.submatch.members/str.pass.cpp b/test/std/re/re.submatch/re.submatch.members/str.pass.cpp
index ca5fd7d78ac7..9a821890178c 100644
--- a/test/std/re/re.submatch/re.submatch.members/str.pass.cpp
+++ b/test/std/re/re.submatch/re.submatch.members/str.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.submatch/re.submatch.op/compare.pass.cpp b/test/std/re/re.submatch/re.submatch.op/compare.pass.cpp
index 36376aa0563c..8000ab6b75ce 100644
--- a/test/std/re/re.submatch/re.submatch.op/compare.pass.cpp
+++ b/test/std/re/re.submatch/re.submatch.op/compare.pass.cpp
@@ -215,6 +215,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 template <class CharT>
 void
@@ -282,6 +283,6 @@ int main()
     test(std::string("1234"), std::string("123"));
     test(std::wstring(L"123"), std::wstring(L"123"));
     test(std::wstring(L"1234"), std::wstring(L"123"));
-    test(std::string("123\00056", 6), std::string("123\00056", 6), false);
-    test(std::wstring(L"123\00056", 6), std::wstring(L"123\00056", 6), false);
+    test(std::string("123\000" "56", 6), std::string("123\000" "56", 6), false);
+    test(std::wstring(L"123\000" L"56", 6), std::wstring(L"123\000" L"56", 6), false);
 }
diff --git a/test/std/re/re.submatch/re.submatch.op/stream.pass.cpp b/test/std/re/re.submatch/re.submatch.op/stream.pass.cpp
index 050bb062e710..9f8c9869e12e 100644
--- a/test/std/re/re.submatch/re.submatch.op/stream.pass.cpp
+++ b/test/std/re/re.submatch/re.submatch.op/stream.pass.cpp
@@ -18,6 +18,7 @@
 #include <regex>
 #include <sstream>
 #include <cassert>
+#include "test_macros.h"
 
 template <class CharT>
 void
diff --git a/test/std/re/re.submatch/types.pass.cpp b/test/std/re/re.submatch/types.pass.cpp
index 47c79149a8d3..e5a00ca0416c 100644
--- a/test/std/re/re.submatch/types.pass.cpp
+++ b/test/std/re/re.submatch/types.pass.cpp
@@ -26,6 +26,7 @@
 #include <regex>
 #include <type_traits>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.syn/cmatch.pass.cpp b/test/std/re/re.syn/cmatch.pass.cpp
index 1364b7873ea5..bf467bcbc772 100644
--- a/test/std/re/re.syn/cmatch.pass.cpp
+++ b/test/std/re/re.syn/cmatch.pass.cpp
@@ -13,6 +13,7 @@
 
 #include <regex>
 #include <type_traits>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.syn/cregex_iterator.pass.cpp b/test/std/re/re.syn/cregex_iterator.pass.cpp
index 7b6ac133f5ac..ed5839da0ee5 100644
--- a/test/std/re/re.syn/cregex_iterator.pass.cpp
+++ b/test/std/re/re.syn/cregex_iterator.pass.cpp
@@ -13,6 +13,7 @@
 
 #include <regex>
 #include <type_traits>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.syn/cregex_token_iterator.pass.cpp b/test/std/re/re.syn/cregex_token_iterator.pass.cpp
index 36ee9b66ea9d..85dca0cf2602 100644
--- a/test/std/re/re.syn/cregex_token_iterator.pass.cpp
+++ b/test/std/re/re.syn/cregex_token_iterator.pass.cpp
@@ -13,6 +13,7 @@
 
 #include <regex>
 #include <type_traits>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.syn/csub_match.pass.cpp b/test/std/re/re.syn/csub_match.pass.cpp
index e0de67b4feb7..2a87d8b6ef5c 100644
--- a/test/std/re/re.syn/csub_match.pass.cpp
+++ b/test/std/re/re.syn/csub_match.pass.cpp
@@ -13,6 +13,7 @@
 
 #include <regex>
 #include <type_traits>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.syn/regex.pass.cpp b/test/std/re/re.syn/regex.pass.cpp
index a208442b966c..32fcb82f1a9c 100644
--- a/test/std/re/re.syn/regex.pass.cpp
+++ b/test/std/re/re.syn/regex.pass.cpp
@@ -13,6 +13,7 @@
 
 #include <regex>
 #include <type_traits>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.syn/smatch.pass.cpp b/test/std/re/re.syn/smatch.pass.cpp
index 87323538968e..e2fc061133af 100644
--- a/test/std/re/re.syn/smatch.pass.cpp
+++ b/test/std/re/re.syn/smatch.pass.cpp
@@ -13,6 +13,7 @@
 
 #include <regex>
 #include <type_traits>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.syn/sregex_iterator.pass.cpp b/test/std/re/re.syn/sregex_iterator.pass.cpp
index 7acd96194b0e..146316408ba6 100644
--- a/test/std/re/re.syn/sregex_iterator.pass.cpp
+++ b/test/std/re/re.syn/sregex_iterator.pass.cpp
@@ -13,6 +13,7 @@
 
 #include <regex>
 #include <type_traits>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.syn/sregex_token_iterator.pass.cpp b/test/std/re/re.syn/sregex_token_iterator.pass.cpp
index 185fd627b4fb..aa85680c5a3b 100644
--- a/test/std/re/re.syn/sregex_token_iterator.pass.cpp
+++ b/test/std/re/re.syn/sregex_token_iterator.pass.cpp
@@ -13,6 +13,7 @@
 
 #include <regex>
 #include <type_traits>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.syn/ssub_match.pass.cpp b/test/std/re/re.syn/ssub_match.pass.cpp
index b378339664c0..181b7a307b58 100644
--- a/test/std/re/re.syn/ssub_match.pass.cpp
+++ b/test/std/re/re.syn/ssub_match.pass.cpp
@@ -13,6 +13,7 @@
 
 #include <regex>
 #include <type_traits>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.syn/wcmatch.pass.cpp b/test/std/re/re.syn/wcmatch.pass.cpp
index 3ca8ed51eabc..0eb125602305 100644
--- a/test/std/re/re.syn/wcmatch.pass.cpp
+++ b/test/std/re/re.syn/wcmatch.pass.cpp
@@ -13,6 +13,7 @@
 
 #include <regex>
 #include <type_traits>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.syn/wcregex_iterator.pass.cpp b/test/std/re/re.syn/wcregex_iterator.pass.cpp
index 99469ecf82b0..20c0d0d546e8 100644
--- a/test/std/re/re.syn/wcregex_iterator.pass.cpp
+++ b/test/std/re/re.syn/wcregex_iterator.pass.cpp
@@ -13,6 +13,7 @@
 
 #include <regex>
 #include <type_traits>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.syn/wcregex_token_iterator.pass.cpp b/test/std/re/re.syn/wcregex_token_iterator.pass.cpp
index f16911f2985a..01a7f3c746a9 100644
--- a/test/std/re/re.syn/wcregex_token_iterator.pass.cpp
+++ b/test/std/re/re.syn/wcregex_token_iterator.pass.cpp
@@ -13,6 +13,7 @@
 
 #include <regex>
 #include <type_traits>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.syn/wcsub_match.pass.cpp b/test/std/re/re.syn/wcsub_match.pass.cpp
index 7e8c872b6033..f757d3f7c5cc 100644
--- a/test/std/re/re.syn/wcsub_match.pass.cpp
+++ b/test/std/re/re.syn/wcsub_match.pass.cpp
@@ -13,6 +13,7 @@
 
 #include <regex>
 #include <type_traits>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.syn/wregex.pass.cpp b/test/std/re/re.syn/wregex.pass.cpp
index 635eac0176cc..23be43baa914 100644
--- a/test/std/re/re.syn/wregex.pass.cpp
+++ b/test/std/re/re.syn/wregex.pass.cpp
@@ -13,6 +13,7 @@
 
 #include <regex>
 #include <type_traits>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.syn/wsmatch.pass.cpp b/test/std/re/re.syn/wsmatch.pass.cpp
index 092c7d16d7a7..1483808bd832 100644
--- a/test/std/re/re.syn/wsmatch.pass.cpp
+++ b/test/std/re/re.syn/wsmatch.pass.cpp
@@ -13,6 +13,7 @@
 
 #include <regex>
 #include <type_traits>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.syn/wsregex_iterator.pass.cpp b/test/std/re/re.syn/wsregex_iterator.pass.cpp
index 0052716e46d8..436e6d717f8a 100644
--- a/test/std/re/re.syn/wsregex_iterator.pass.cpp
+++ b/test/std/re/re.syn/wsregex_iterator.pass.cpp
@@ -13,6 +13,7 @@
 
 #include <regex>
 #include <type_traits>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.syn/wsregex_token_iterator.pass.cpp b/test/std/re/re.syn/wsregex_token_iterator.pass.cpp
index dc71991eb9b1..5ceb241f3dc1 100644
--- a/test/std/re/re.syn/wsregex_token_iterator.pass.cpp
+++ b/test/std/re/re.syn/wsregex_token_iterator.pass.cpp
@@ -13,6 +13,7 @@
 
 #include <regex>
 #include <type_traits>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.syn/wssub_match.pass.cpp b/test/std/re/re.syn/wssub_match.pass.cpp
index 2360a15513db..23b92bb2d4ee 100644
--- a/test/std/re/re.syn/wssub_match.pass.cpp
+++ b/test/std/re/re.syn/wssub_match.pass.cpp
@@ -13,6 +13,7 @@
 
 #include <regex>
 #include <type_traits>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.traits/default.pass.cpp b/test/std/re/re.traits/default.pass.cpp
index defadd95378b..b1e23587d21f 100644
--- a/test/std/re/re.traits/default.pass.cpp
+++ b/test/std/re/re.traits/default.pass.cpp
@@ -19,6 +19,7 @@
 #include <regex>
 #include <cassert>
 
+#include "test_macros.h"
 #include "platform_support.h" // locale name macros
 
 int main()
diff --git a/test/std/re/re.traits/getloc.pass.cpp b/test/std/re/re.traits/getloc.pass.cpp
index 0b7810a2099d..929659d004b0 100644
--- a/test/std/re/re.traits/getloc.pass.cpp
+++ b/test/std/re/re.traits/getloc.pass.cpp
@@ -18,6 +18,7 @@
 #include <regex>
 #include <cassert>
 
+#include "test_macros.h"
 #include "platform_support.h" // locale name macros
 
 int main()
diff --git a/test/std/re/re.traits/imbue.pass.cpp b/test/std/re/re.traits/imbue.pass.cpp
index 6988058a832c..04b4f5f7692b 100644
--- a/test/std/re/re.traits/imbue.pass.cpp
+++ b/test/std/re/re.traits/imbue.pass.cpp
@@ -19,6 +19,7 @@
 #include <locale>
 #include <cassert>
 
+#include "test_macros.h"
 #include "platform_support.h" // locale name macros
 
 int main()
diff --git a/test/std/re/re.traits/isctype.pass.cpp b/test/std/re/re.traits/isctype.pass.cpp
index ad69f05ae75e..3d1e7470a883 100644
--- a/test/std/re/re.traits/isctype.pass.cpp
+++ b/test/std/re/re.traits/isctype.pass.cpp
@@ -13,8 +13,13 @@
 
 // bool isctype(charT c, char_class_type f) const;
 
+// TODO(EricWF): This test takes 40+ minutes to build with Clang 3.8 under ASAN or MSAN.
+// UNSUPPORTED: asan, msan
+
+
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.traits/length.pass.cpp b/test/std/re/re.traits/length.pass.cpp
index 473c233c531e..b80f9b5b400a 100644
--- a/test/std/re/re.traits/length.pass.cpp
+++ b/test/std/re/re.traits/length.pass.cpp
@@ -16,6 +16,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.traits/lookup_classname.pass.cpp b/test/std/re/re.traits/lookup_classname.pass.cpp
index 0b1b18eb5077..4f7cf61ebf99 100644
--- a/test/std/re/re.traits/lookup_classname.pass.cpp
+++ b/test/std/re/re.traits/lookup_classname.pass.cpp
@@ -18,6 +18,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class char_type>
@@ -33,6 +34,19 @@ test(const char_type* A,
 
 int main()
 {
+//  if __regex_word is not distinct from all the classes, bad things happen
+//  See https://llvm.org/bugs/show_bug.cgi?id=26476 for an example.
+    assert((std::ctype_base::space  & std::regex_traits<char>::__regex_word) == 0);
+    assert((std::ctype_base::print  & std::regex_traits<char>::__regex_word) == 0);
+    assert((std::ctype_base::cntrl  & std::regex_traits<char>::__regex_word) == 0);
+    assert((std::ctype_base::upper  & std::regex_traits<char>::__regex_word) == 0);
+    assert((std::ctype_base::lower  & std::regex_traits<char>::__regex_word) == 0);
+    assert((std::ctype_base::alpha  & std::regex_traits<char>::__regex_word) == 0);
+    assert((std::ctype_base::digit  & std::regex_traits<char>::__regex_word) == 0);
+    assert((std::ctype_base::punct  & std::regex_traits<char>::__regex_word) == 0);
+    assert((std::ctype_base::xdigit & std::regex_traits<char>::__regex_word) == 0);
+    assert((std::ctype_base::blank  & std::regex_traits<char>::__regex_word) == 0);
+
     test("d", std::ctype_base::digit);
     test("D", std::ctype_base::digit);
     test("d", std::ctype_base::digit, true);
diff --git a/test/std/re/re.traits/lookup_collatename.pass.cpp b/test/std/re/re.traits/lookup_collatename.pass.cpp
index a7cd5f071561..3aeed7bddf75 100644
--- a/test/std/re/re.traits/lookup_collatename.pass.cpp
+++ b/test/std/re/re.traits/lookup_collatename.pass.cpp
@@ -23,8 +23,9 @@
 #include <regex>
 #include <iterator>
 #include <cassert>
-#include "test_iterators.h"
 
+#include "test_macros.h"
+#include "test_iterators.h"
 #include "platform_support.h" // locale name macros
 
 template <class char_type>
diff --git a/test/std/re/re.traits/transform.pass.cpp b/test/std/re/re.traits/transform.pass.cpp
index 85235e045d88..57e6b753abef 100644
--- a/test/std/re/re.traits/transform.pass.cpp
+++ b/test/std/re/re.traits/transform.pass.cpp
@@ -19,8 +19,8 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 #include "test_iterators.h"
-
 #include "platform_support.h" // locale name macros
 
 int main()
diff --git a/test/std/re/re.traits/transform_primary.pass.cpp b/test/std/re/re.traits/transform_primary.pass.cpp
index 438cd75452bb..03b4f3985a60 100644
--- a/test/std/re/re.traits/transform_primary.pass.cpp
+++ b/test/std/re/re.traits/transform_primary.pass.cpp
@@ -20,8 +20,9 @@
 
 #include <regex>
 #include <cassert>
-#include "test_iterators.h"
 
+#include "test_macros.h"
+#include "test_iterators.h"
 #include "platform_support.h" // locale name macros
 
 int main()
diff --git a/test/std/re/re.traits/translate.pass.cpp b/test/std/re/re.traits/translate.pass.cpp
index c3523387c56b..7eaf30ea71c3 100644
--- a/test/std/re/re.traits/translate.pass.cpp
+++ b/test/std/re/re.traits/translate.pass.cpp
@@ -16,6 +16,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.traits/translate_nocase.pass.cpp b/test/std/re/re.traits/translate_nocase.pass.cpp
index f9fa38ddf26a..bf79629d33b4 100644
--- a/test/std/re/re.traits/translate_nocase.pass.cpp
+++ b/test/std/re/re.traits/translate_nocase.pass.cpp
@@ -25,6 +25,7 @@
 #include <regex>
 #include <cassert>
 
+#include "test_macros.h"
 #include "platform_support.h"
 
 int main()
diff --git a/test/std/re/re.traits/types.pass.cpp b/test/std/re/re.traits/types.pass.cpp
index 50586a1f29f3..611ef04342fe 100644
--- a/test/std/re/re.traits/types.pass.cpp
+++ b/test/std/re/re.traits/types.pass.cpp
@@ -20,6 +20,7 @@
 
 #include <regex>
 #include <type_traits>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/re/re.traits/value.pass.cpp b/test/std/re/re.traits/value.pass.cpp
index 349a29cc6bc1..dfed66c35c46 100644
--- a/test/std/re/re.traits/value.pass.cpp
+++ b/test/std/re/re.traits/value.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main()
 {
diff --git a/test/std/strings/basic.string.literals/literal.pass.cpp b/test/std/strings/basic.string.literals/literal.pass.cpp
index dbb5f681395b..d121e25ba270 100644
--- a/test/std/strings/basic.string.literals/literal.pass.cpp
+++ b/test/std/strings/basic.string.literals/literal.pass.cpp
@@ -7,12 +7,14 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
 #include <string>
 #include <cassert>
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11 
     using namespace std::literals::string_literals;
 
     static_assert ( std::is_same<decltype(   "Hi"s), std::string>::value, "" );
@@ -20,28 +22,27 @@ int main()
     static_assert ( std::is_same<decltype(  L"Hi"s), std::wstring>::value, "" );
     static_assert ( std::is_same<decltype(  u"Hi"s), std::u16string>::value, "" );
     static_assert ( std::is_same<decltype(  U"Hi"s), std::u32string>::value, "" );
-    
+
     std::string foo;
     std::wstring Lfoo;
     std::u16string ufoo;
     std::u32string Ufoo;
-    
+
     foo  =   ""s;     assert( foo.size() == 0);
     foo  = u8""s;     assert( foo.size() == 0);
     Lfoo =  L""s;     assert(Lfoo.size() == 0);
     ufoo =  u""s;     assert(ufoo.size() == 0);
     Ufoo =  U""s;     assert(Ufoo.size() == 0);
-    
+
     foo  =   " "s;     assert( foo.size() == 1);
     foo  = u8" "s;     assert( foo.size() == 1);
     Lfoo =  L" "s;     assert(Lfoo.size() == 1);
     ufoo =  u" "s;     assert(ufoo.size() == 1);
     Ufoo =  U" "s;     assert(Ufoo.size() == 1);
-    
+
     foo  =   "ABC"s;     assert( foo ==   "ABC");   assert( foo == std::string   (  "ABC"));
     foo  = u8"ABC"s;     assert( foo == u8"ABC");   assert( foo == std::string   (u8"ABC"));
     Lfoo =  L"ABC"s;     assert(Lfoo ==  L"ABC");   assert(Lfoo == std::wstring  ( L"ABC"));
     ufoo =  u"ABC"s;     assert(ufoo ==  u"ABC");   assert(ufoo == std::u16string( u"ABC"));
     Ufoo =  U"ABC"s;     assert(Ufoo ==  U"ABC");   assert(Ufoo == std::u32string( U"ABC"));
-#endif
 }
diff --git a/test/std/strings/basic.string.literals/literal1.fail.cpp b/test/std/strings/basic.string.literals/literal1.fail.cpp
index 6ba0b30d458d..721440d8a3a5 100644
--- a/test/std/strings/basic.string.literals/literal1.fail.cpp
+++ b/test/std/strings/basic.string.literals/literal1.fail.cpp
@@ -7,16 +7,15 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
 #include <string>
 #include <cassert>
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11 
     using std::string;
 
     string foo  =   ""s;  // should fail w/conversion operator not found
-#else
-#error
-#endif
 }
diff --git a/test/std/strings/basic.string.literals/literal1.pass.cpp b/test/std/strings/basic.string.literals/literal1.pass.cpp
index f5143746b0bb..f0b7b463f85e 100644
--- a/test/std/strings/basic.string.literals/literal1.pass.cpp
+++ b/test/std/strings/basic.string.literals/literal1.pass.cpp
@@ -7,14 +7,15 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
 #include <string>
 #include <cassert>
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11 
     using namespace std::literals;
 
     std::string foo  =   ""s;
-#endif
 }
diff --git a/test/std/strings/basic.string.literals/literal2.fail.cpp b/test/std/strings/basic.string.literals/literal2.fail.cpp
index 68f1d254e327..99f92fde9724 100644
--- a/test/std/strings/basic.string.literals/literal2.fail.cpp
+++ b/test/std/strings/basic.string.literals/literal2.fail.cpp
@@ -7,14 +7,13 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
 #include <string>
 #include <cassert>
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11 
     std::string foo  =   ""s;  // should fail w/conversion operator not found
-#else
-#error
-#endif
 }
diff --git a/test/std/strings/basic.string.literals/literal2.pass.cpp b/test/std/strings/basic.string.literals/literal2.pass.cpp
index 86d28e60e52b..3cc2936a115d 100644
--- a/test/std/strings/basic.string.literals/literal2.pass.cpp
+++ b/test/std/strings/basic.string.literals/literal2.pass.cpp
@@ -7,14 +7,15 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
 #include <string>
 #include <cassert>
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11 
     using namespace std::literals::string_literals;
 
     std::string foo  =   ""s;
-#endif
 }
diff --git a/test/std/strings/basic.string.literals/literal3.pass.cpp b/test/std/strings/basic.string.literals/literal3.pass.cpp
index 98e3e40e058c..d6e8c8f88ecd 100644
--- a/test/std/strings/basic.string.literals/literal3.pass.cpp
+++ b/test/std/strings/basic.string.literals/literal3.pass.cpp
@@ -7,14 +7,15 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
 #include <string>
 #include <cassert>
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11 
     using namespace std;
 
     string foo  =   ""s;
-#endif
 }
diff --git a/test/std/strings/basic.string/string.access/at.pass.cpp b/test/std/strings/basic.string/string.access/at.pass.cpp
index 87998e18c581..8dc0c57cb7b4 100644
--- a/test/std/strings/basic.string/string.access/at.pass.cpp
+++ b/test/std/strings/basic.string/string.access/at.pass.cpp
@@ -46,7 +46,7 @@ int main()
     test(S("123"), 2);
     test(S("123"), 3);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), 0);
diff --git a/test/std/strings/basic.string/string.access/back.pass.cpp b/test/std/strings/basic.string/string.access/back.pass.cpp
index e91521441b80..adf22bf0d27b 100644
--- a/test/std/strings/basic.string/string.access/back.pass.cpp
+++ b/test/std/strings/basic.string/string.access/back.pass.cpp
@@ -39,7 +39,7 @@ int main()
     test(S("1"));
     test(S("1234567890123456789012345678901234567890"));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S("1"));
diff --git a/test/std/strings/basic.string/string.access/db_back.pass.cpp b/test/std/strings/basic.string/string.access/db_back.pass.cpp
index 2b31fabc7c70..e65ef2cef88d 100644
--- a/test/std/strings/basic.string/string.access/db_back.pass.cpp
+++ b/test/std/strings/basic.string/string.access/db_back.pass.cpp
@@ -33,7 +33,7 @@ int main()
     assert(s.back() == 0);
     assert(false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S s(1, '\0');
diff --git a/test/std/strings/basic.string/string.access/db_cback.pass.cpp b/test/std/strings/basic.string/string.access/db_cback.pass.cpp
index 7feb4239f07a..ee99aee10e32 100644
--- a/test/std/strings/basic.string/string.access/db_cback.pass.cpp
+++ b/test/std/strings/basic.string/string.access/db_cback.pass.cpp
@@ -31,7 +31,7 @@ int main()
     assert(s.back() == 0);
     assert(false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     const S s;
diff --git a/test/std/strings/basic.string/string.access/db_cfront.pass.cpp b/test/std/strings/basic.string/string.access/db_cfront.pass.cpp
index 9f7785b85cda..13049624534f 100644
--- a/test/std/strings/basic.string/string.access/db_cfront.pass.cpp
+++ b/test/std/strings/basic.string/string.access/db_cfront.pass.cpp
@@ -31,7 +31,7 @@ int main()
     assert(s.front() == 0);
     assert(false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     const S s;
diff --git a/test/std/strings/basic.string/string.access/db_cindex.pass.cpp b/test/std/strings/basic.string/string.access/db_cindex.pass.cpp
index 6294200104ba..f96ead7bf251 100644
--- a/test/std/strings/basic.string/string.access/db_cindex.pass.cpp
+++ b/test/std/strings/basic.string/string.access/db_cindex.pass.cpp
@@ -32,7 +32,7 @@ int main()
     assert(s[1] == 0);
     assert(false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     const S s;
diff --git a/test/std/strings/basic.string/string.access/db_front.pass.cpp b/test/std/strings/basic.string/string.access/db_front.pass.cpp
index ff675bc5c217..881a5ede3738 100644
--- a/test/std/strings/basic.string/string.access/db_front.pass.cpp
+++ b/test/std/strings/basic.string/string.access/db_front.pass.cpp
@@ -33,7 +33,7 @@ int main()
     assert(s.front() == 0);
     assert(false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S s(1, '\0');
diff --git a/test/std/strings/basic.string/string.access/db_index.pass.cpp b/test/std/strings/basic.string/string.access/db_index.pass.cpp
index b20e20188023..981a55d11037 100644
--- a/test/std/strings/basic.string/string.access/db_index.pass.cpp
+++ b/test/std/strings/basic.string/string.access/db_index.pass.cpp
@@ -32,7 +32,7 @@ int main()
     assert(s[1] == 0);
     assert(false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S s;
diff --git a/test/std/strings/basic.string/string.access/front.pass.cpp b/test/std/strings/basic.string/string.access/front.pass.cpp
index ed80916f16f0..5400ddb39dc0 100644
--- a/test/std/strings/basic.string/string.access/front.pass.cpp
+++ b/test/std/strings/basic.string/string.access/front.pass.cpp
@@ -39,7 +39,7 @@ int main()
     test(S("1"));
     test(S("1234567890123456789012345678901234567890"));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S("1"));
diff --git a/test/std/strings/basic.string/string.access/index.pass.cpp b/test/std/strings/basic.string/string.access/index.pass.cpp
index cd3162385160..b45a399320ba 100644
--- a/test/std/strings/basic.string/string.access/index.pass.cpp
+++ b/test/std/strings/basic.string/string.access/index.pass.cpp
@@ -36,7 +36,7 @@ int main()
     const S s2 = S();
     assert(s2[0] == '\0');
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S s("0123456789");
diff --git a/test/std/strings/basic.string/string.capacity/capacity.pass.cpp b/test/std/strings/basic.string/string.capacity/capacity.pass.cpp
index c05346a633e9..4b09c096792c 100644
--- a/test/std/strings/basic.string/string.capacity/capacity.pass.cpp
+++ b/test/std/strings/basic.string/string.capacity/capacity.pass.cpp
@@ -49,7 +49,7 @@ int main()
     s.erase(50);
     test(s);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S s;
diff --git a/test/std/strings/basic.string/string.capacity/clear.pass.cpp b/test/std/strings/basic.string/string.capacity/clear.pass.cpp
index b73af7599344..e0254c0460e4 100644
--- a/test/std/strings/basic.string/string.capacity/clear.pass.cpp
+++ b/test/std/strings/basic.string/string.capacity/clear.pass.cpp
@@ -39,7 +39,7 @@ int main()
     s.erase(50);
     test(s);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S s;
diff --git a/test/std/strings/basic.string/string.capacity/empty.pass.cpp b/test/std/strings/basic.string/string.capacity/empty.pass.cpp
index ac65f5144858..fbed5c36c3f4 100644
--- a/test/std/strings/basic.string/string.capacity/empty.pass.cpp
+++ b/test/std/strings/basic.string/string.capacity/empty.pass.cpp
@@ -31,7 +31,7 @@ int main()
     test(S("123"));
     test(S("12345678901234567890123456789012345678901234567890"));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
diff --git a/test/std/strings/basic.string/string.capacity/length.pass.cpp b/test/std/strings/basic.string/string.capacity/length.pass.cpp
index d3ae1aaee036..13e966dc619e 100644
--- a/test/std/strings/basic.string/string.capacity/length.pass.cpp
+++ b/test/std/strings/basic.string/string.capacity/length.pass.cpp
@@ -31,7 +31,7 @@ int main()
     test(S("123"));
     test(S("12345678901234567890123456789012345678901234567890"));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
diff --git a/test/std/strings/basic.string/string.capacity/max_size.pass.cpp b/test/std/strings/basic.string/string.capacity/max_size.pass.cpp
index d857be28a6c9..fca14ddca561 100644
--- a/test/std/strings/basic.string/string.capacity/max_size.pass.cpp
+++ b/test/std/strings/basic.string/string.capacity/max_size.pass.cpp
@@ -63,7 +63,7 @@ int main()
     test(S("123"));
     test(S("12345678901234567890123456789012345678901234567890"));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
diff --git a/test/std/strings/basic.string/string.capacity/over_max_size.pass.cpp b/test/std/strings/basic.string/string.capacity/over_max_size.pass.cpp
index 9c8f67950fb4..e92a0e1054f6 100644
--- a/test/std/strings/basic.string/string.capacity/over_max_size.pass.cpp
+++ b/test/std/strings/basic.string/string.capacity/over_max_size.pass.cpp
@@ -37,7 +37,7 @@ int main()
     test(S("123"));
     test(S("12345678901234567890123456789012345678901234567890"));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
diff --git a/test/std/strings/basic.string/string.capacity/reserve.pass.cpp b/test/std/strings/basic.string/string.capacity/reserve.pass.cpp
index 569ca760c7ce..b2c254d1fb25 100644
--- a/test/std/strings/basic.string/string.capacity/reserve.pass.cpp
+++ b/test/std/strings/basic.string/string.capacity/reserve.pass.cpp
@@ -16,6 +16,7 @@
 #include <stdexcept>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -25,7 +26,7 @@ test(S s)
     typename S::size_type old_cap = s.capacity();
     S s0 = s;
     s.reserve();
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s == s0);
     assert(s.capacity() <= old_cap);
     assert(s.capacity() >= s.size());
@@ -83,7 +84,7 @@ int main()
     test(s, S::npos);
     }
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     {
diff --git a/test/std/strings/basic.string/string.capacity/resize_size.pass.cpp b/test/std/strings/basic.string/string.capacity/resize_size.pass.cpp
index 16eca38e8012..558941599578 100644
--- a/test/std/strings/basic.string/string.capacity/resize_size.pass.cpp
+++ b/test/std/strings/basic.string/string.capacity/resize_size.pass.cpp
@@ -16,6 +16,7 @@
 #include <stdexcept>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -25,7 +26,7 @@ test(S s, typename S::size_type n, S expected)
     try
     {
         s.resize(n);
-        assert(s.__invariants());
+        LIBCPP_ASSERT(s.__invariants());
         assert(n <= s.max_size());
         assert(s == expected);
     }
@@ -56,7 +57,7 @@ int main()
          S("12345678901234567890123456789012345678901234567890\0\0\0\0\0\0\0\0\0\0", 60));
     test(S(), S::npos, S("not going to happen"));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), 0, S());
diff --git a/test/std/strings/basic.string/string.capacity/resize_size_char.pass.cpp b/test/std/strings/basic.string/string.capacity/resize_size_char.pass.cpp
index cb01be01f34b..79f972b2fee3 100644
--- a/test/std/strings/basic.string/string.capacity/resize_size_char.pass.cpp
+++ b/test/std/strings/basic.string/string.capacity/resize_size_char.pass.cpp
@@ -16,6 +16,7 @@
 #include <stdexcept>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -25,7 +26,7 @@ test(S s, typename S::size_type n, typename S::value_type c, S expected)
     try
     {
         s.resize(n, c);
-        assert(s.__invariants());
+        LIBCPP_ASSERT(s.__invariants());
         assert(n <= s.max_size());
         assert(s == expected);
     }
@@ -56,7 +57,7 @@ int main()
          S("12345678901234567890123456789012345678901234567890aaaaaaaaaa"));
     test(S(), S::npos, 'a', S("not going to happen"));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), 0, 'a', S());
diff --git a/test/std/strings/basic.string/string.capacity/shrink_to_fit.pass.cpp b/test/std/strings/basic.string/string.capacity/shrink_to_fit.pass.cpp
index aacbffd098f0..656ea1d11a7c 100644
--- a/test/std/strings/basic.string/string.capacity/shrink_to_fit.pass.cpp
+++ b/test/std/strings/basic.string/string.capacity/shrink_to_fit.pass.cpp
@@ -14,6 +14,7 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -23,7 +24,7 @@ test(S s)
     typename S::size_type old_cap = s.capacity();
     S s0 = s;
     s.shrink_to_fit();
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s == s0);
     assert(s.capacity() <= old_cap);
     assert(s.capacity() >= s.size());
@@ -44,7 +45,7 @@ int main()
     s.erase(50);
     test(s);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S s;
diff --git a/test/std/strings/basic.string/string.capacity/size.pass.cpp b/test/std/strings/basic.string/string.capacity/size.pass.cpp
index 21b475a8113f..4657aea442f7 100644
--- a/test/std/strings/basic.string/string.capacity/size.pass.cpp
+++ b/test/std/strings/basic.string/string.capacity/size.pass.cpp
@@ -31,7 +31,7 @@ int main()
     test(S("123"), 3);
     test(S("12345678901234567890123456789012345678901234567890"), 50);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), 0);
diff --git a/test/std/strings/basic.string/string.cons/alloc.pass.cpp b/test/std/strings/basic.string/string.cons/alloc.pass.cpp
index 1c4f2044834e..a803d331b8f6 100644
--- a/test/std/strings/basic.string/string.cons/alloc.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/alloc.pass.cpp
@@ -29,7 +29,7 @@ test()
 	static_assert((noexcept(S()) == noexcept(typename S::allocator_type())), "" );
 #endif
     S s;
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s.data());
     assert(s.size() == 0);
     assert(s.capacity() >= s.size());
@@ -42,7 +42,7 @@ test()
 	static_assert((noexcept(S(typename S::allocator_type())) == std::is_nothrow_copy_constructible<typename S::allocator_type>::value), "" );
 #endif
     S s(typename S::allocator_type(5));
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s.data());
     assert(s.size() == 0);
     assert(s.capacity() >= s.size());
@@ -63,7 +63,7 @@ test2()
 	static_assert((noexcept(S()) == noexcept(typename S::allocator_type())), "" );
 #endif
     S s;
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s.data());
     assert(s.size() == 0);
     assert(s.capacity() >= s.size());
@@ -76,7 +76,7 @@ test2()
 	static_assert((noexcept(S(typename S::allocator_type())) == std::is_nothrow_copy_constructible<typename S::allocator_type>::value), "" );
 #endif
     S s(typename S::allocator_type{});
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s.data());
     assert(s.size() == 0);
     assert(s.capacity() >= s.size());
diff --git a/test/std/strings/basic.string/string.cons/char_assignment.pass.cpp b/test/std/strings/basic.string/string.cons/char_assignment.pass.cpp
index 1c582bc51637..f6bacb70e4ce 100644
--- a/test/std/strings/basic.string/string.cons/char_assignment.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/char_assignment.pass.cpp
@@ -14,6 +14,7 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -22,7 +23,7 @@ test(S s1, typename S::value_type s2)
 {
     typedef typename S::traits_type T;
     s1 = s2;
-    assert(s1.__invariants());
+    LIBCPP_ASSERT(s1.__invariants());
     assert(s1.size() == 1);
     assert(T::eq(s1[0], s2));
     assert(s1.capacity() >= s1.size());
@@ -37,7 +38,7 @@ int main()
     test(S("123456789"), 'a');
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), 'a');
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), 'a');
diff --git a/test/std/strings/basic.string/string.cons/copy.pass.cpp b/test/std/strings/basic.string/string.cons/copy.pass.cpp
index 9c9fc3230668..cc4deb992a8b 100644
--- a/test/std/strings/basic.string/string.cons/copy.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/copy.pass.cpp
@@ -14,6 +14,7 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
@@ -22,7 +23,7 @@ void
 test(S s1)
 {
     S s2 = s1;
-    assert(s2.__invariants());
+    LIBCPP_ASSERT(s2.__invariants());
     assert(s2 == s1);
     assert(s2.capacity() >= s2.size());
     assert(s2.get_allocator() == s1.get_allocator());
@@ -37,7 +38,7 @@ int main()
     test(S("1", A(5)));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef min_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
diff --git a/test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp b/test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp
index cf8021019a2e..b3447b94b803 100644
--- a/test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp
@@ -14,6 +14,7 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
@@ -22,7 +23,7 @@ void
 test(S s1, const typename S::allocator_type& a)
 {
     S s2(s1, a);
-    assert(s2.__invariants());
+    LIBCPP_ASSERT(s2.__invariants());
     assert(s2 == s1);
     assert(s2.capacity() >= s2.size());
     assert(s2.get_allocator() == a);
@@ -37,7 +38,7 @@ int main()
     test(S("1"), A(5));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A(7));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef min_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
diff --git a/test/std/strings/basic.string/string.cons/copy_assignment.pass.cpp b/test/std/strings/basic.string/string.cons/copy_assignment.pass.cpp
index ccb6c599974b..b1e9108e90ba 100644
--- a/test/std/strings/basic.string/string.cons/copy_assignment.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/copy_assignment.pass.cpp
@@ -15,6 +15,7 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -22,7 +23,7 @@ void
 test(S s1, const S& s2)
 {
     s1 = s2;
-    assert(s1.__invariants());
+    LIBCPP_ASSERT(s1.__invariants());
     assert(s1 == s2);
     assert(s1.capacity() >= s1.size());
 }
@@ -47,7 +48,7 @@ int main()
            "1234567890123456789012345678901234567890123456789012345678901234567890"),
          S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), S());
diff --git a/test/std/strings/basic.string/string.cons/default_noexcept.pass.cpp b/test/std/strings/basic.string/string.cons/default_noexcept.pass.cpp
index af117103d827..87698ec55103 100644
--- a/test/std/strings/basic.string/string.cons/default_noexcept.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/default_noexcept.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <string>
 
 // basic_string()
@@ -29,7 +31,6 @@ struct some_alloc
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::string C;
         static_assert(std::is_nothrow_default_constructible<C>::value, "");
@@ -42,5 +43,4 @@ int main()
         typedef std::basic_string<char, std::char_traits<char>, some_alloc<char>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/strings/basic.string/string.cons/dtor_noexcept.pass.cpp b/test/std/strings/basic.string/string.cons/dtor_noexcept.pass.cpp
index b3cc127fbc46..c4ac1f1a47bb 100644
--- a/test/std/strings/basic.string/string.cons/dtor_noexcept.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/dtor_noexcept.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <string>
 
 // ~basic_string() // implied noexcept;
@@ -16,8 +18,6 @@
 
 #include "test_allocator.h"
 
-#if __has_feature(cxx_noexcept)
-
 template <class T>
 struct some_alloc
 {
@@ -26,11 +26,8 @@ struct some_alloc
     ~some_alloc() noexcept(false);
 };
 
-#endif
-
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::string C;
         static_assert(std::is_nothrow_destructible<C>::value, "");
@@ -43,5 +40,4 @@ int main()
         typedef std::basic_string<char, std::char_traits<char>, some_alloc<char>> C;
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
-#endif
 }
diff --git a/test/std/strings/basic.string/string.cons/initializer_list.pass.cpp b/test/std/strings/basic.string/string.cons/initializer_list.pass.cpp
index d6ff8504e9da..3007b9e8f68c 100644
--- a/test/std/strings/basic.string/string.cons/initializer_list.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/initializer_list.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <string>
 
 // basic_string(initializer_list<charT> il, const Allocator& a = Allocator());
@@ -19,7 +21,6 @@
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     {
         std::string s = {'a', 'b', 'c'};
         assert(s == "abc");
@@ -29,7 +30,6 @@ int main()
         s = {L'a', L'b', L'c'};
         assert(s == L"abc");
     }
-#if __cplusplus >= 201103L
     {
         typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
         S s = {'a', 'b', 'c'};
@@ -41,6 +41,4 @@ int main()
         s = {L'a', L'b', L'c'};
         assert(s == L"abc");
     }
-#endif
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }
diff --git a/test/std/strings/basic.string/string.cons/initializer_list_assignment.pass.cpp b/test/std/strings/basic.string/string.cons/initializer_list_assignment.pass.cpp
index 753076895359..20279c853eaf 100644
--- a/test/std/strings/basic.string/string.cons/initializer_list_assignment.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/initializer_list_assignment.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <string>
 
 // basic_string& operator=(initializer_list<charT> il);
@@ -18,19 +20,15 @@
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     {
         std::string s;
         s = {'a', 'b', 'c'};
         assert(s == "abc");
     }
-#if __cplusplus >= 201103L
     {
         typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
         S s;
         s = {'a', 'b', 'c'};
         assert(s == "abc");
     }
-#endif
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }
diff --git a/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp b/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp
index 664cb80b10fe..cb0792ab23b3 100644
--- a/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp
@@ -17,6 +17,7 @@
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_allocator.h"
 #include "../input_iterator.h"
 #include "min_allocator.h"
@@ -30,7 +31,7 @@ test(It first, It last)
     typedef typename S::traits_type T;
     typedef typename S::allocator_type A;
     S s2(first, last);
-    assert(s2.__invariants());
+    LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == std::distance(first, last));
     unsigned i = 0;
     for (It it = first; it != last; ++it, ++i)
@@ -47,7 +48,7 @@ test(It first, It last, const A& a)
     typedef std::basic_string<charT, std::char_traits<charT>, A> S;
     typedef typename S::traits_type T;
     S s2(first, last, a);
-    assert(s2.__invariants());
+    LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == std::distance(first, last));
     unsigned i = 0;
     for (It it = first; it != last; ++it, ++i)
@@ -86,7 +87,7 @@ int main()
     test(input_iterator<const char*>(s), input_iterator<const char*>(s+50));
     test(input_iterator<const char*>(s), input_iterator<const char*>(s+50), A(2));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef min_allocator<char> A;
     const char* s = "12345678901234567890123456789012345678901234567890";
diff --git a/test/std/strings/basic.string/string.cons/move.pass.cpp b/test/std/strings/basic.string/string.cons/move.pass.cpp
index b94f189ecb46..9ed244406d01 100644
--- a/test/std/strings/basic.string/string.cons/move.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/move.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <string>
 
 // basic_string(basic_string<charT,traits,Allocator>&& str);
@@ -14,8 +16,7 @@
 #include <string>
 #include <cassert>
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
+#include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
@@ -25,18 +26,15 @@ test(S s0)
 {
     S s1 = s0;
     S s2 = std::move(s0);
-    assert(s2.__invariants());
-    assert(s0.__invariants());
+    LIBCPP_ASSERT(s2.__invariants());
+    LIBCPP_ASSERT(s0.__invariants());
     assert(s2 == s1);
     assert(s2.capacity() >= s2.size());
     assert(s2.get_allocator() == s1.get_allocator());
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
     typedef test_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
@@ -44,7 +42,6 @@ int main()
     test(S("1", A(5)));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)));
     }
-#if __cplusplus >= 201103L
     {
     typedef min_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
@@ -52,6 +49,4 @@ int main()
     test(S("1", A()));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()));
     }
-#endif
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/strings/basic.string/string.cons/move_alloc.pass.cpp b/test/std/strings/basic.string/string.cons/move_alloc.pass.cpp
index a232a46bd9fb..d4866921af7a 100644
--- a/test/std/strings/basic.string/string.cons/move_alloc.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/move_alloc.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <string>
 
 // basic_string(basic_string&& str, const Allocator& alloc);
@@ -14,8 +16,6 @@
 #include <string>
 #include <cassert>
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
@@ -27,23 +27,16 @@ test(S s0, const typename S::allocator_type& a)
 {
     S s1 = s0;
     S s2(std::move(s0), a);
-    assert(s2.__invariants());
-    assert(s0.__invariants());
+    LIBCPP_ASSERT(s2.__invariants());
+    LIBCPP_ASSERT(s0.__invariants());
     assert(s2 == s1);
     assert(s2.capacity() >= s2.size());
     assert(s2.get_allocator() == a);
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-// #if _LIBCPP_STD_VER <= 14
-//         _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
-// #else
-//         _NOEXCEPT;
-// #endif
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
     typedef test_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
@@ -70,8 +63,6 @@ int main()
     S s2 (std::move(s1), A(1));
     }
     assert ( test_alloc_base::alloc_count == alloc_count );
-    
-#if TEST_STD_VER >= 11
     {
     typedef min_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
@@ -84,6 +75,4 @@ int main()
     test(S("1"), A());
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A());
     }
-#endif
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/strings/basic.string/string.cons/move_assign_noexcept.pass.cpp b/test/std/strings/basic.string/string.cons/move_assign_noexcept.pass.cpp
index d7bd5e06bbe9..136a60fe627b 100644
--- a/test/std/strings/basic.string/string.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/move_assign_noexcept.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <string>
 
 // basic_string& operator=(basic_string&& c)
@@ -36,7 +38,7 @@ template <class T>
 struct some_alloc2
 {
     typedef T value_type;
-    
+
     some_alloc2() {}
     some_alloc2(const some_alloc2&);
     void deallocate(void*, unsigned) {}
@@ -49,7 +51,7 @@ template <class T>
 struct some_alloc3
 {
     typedef T value_type;
-    
+
     some_alloc3() {}
     some_alloc3(const some_alloc3&);
     void deallocate(void*, unsigned) {}
@@ -60,7 +62,6 @@ struct some_alloc3
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::string C;
         static_assert(std::is_nothrow_move_assignable<C>::value, "");
@@ -90,6 +91,4 @@ int main()
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
 #endif
-
-#endif
 }
diff --git a/test/std/strings/basic.string/string.cons/move_assignment.pass.cpp b/test/std/strings/basic.string/string.cons/move_assignment.pass.cpp
index 5bc1c8a9153f..006b5b9b4cb0 100644
--- a/test/std/strings/basic.string/string.cons/move_assignment.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/move_assignment.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <string>
 
 // basic_string<charT,traits,Allocator>&
@@ -15,8 +17,7 @@
 #include <string>
 #include <cassert>
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
+#include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
@@ -26,17 +27,14 @@ test(S s1, S s2)
 {
     S s0 = s2;
     s1 = std::move(s2);
-    assert(s1.__invariants());
-    assert(s2.__invariants());
+    LIBCPP_ASSERT(s1.__invariants());
+    LIBCPP_ASSERT(s2.__invariants());
     assert(s1 == s0);
     assert(s1.capacity() >= s1.size());
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
     typedef std::string S;
     test(S(), S());
@@ -55,7 +53,6 @@ int main()
            "1234567890123456789012345678901234567890123456789012345678901234567890"),
          S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
     }
-#if __cplusplus >= 201103L
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), S());
@@ -74,6 +71,4 @@ int main()
            "1234567890123456789012345678901234567890123456789012345678901234567890"),
          S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
     }
-#endif
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/strings/basic.string/string.cons/move_noexcept.pass.cpp b/test/std/strings/basic.string/string.cons/move_noexcept.pass.cpp
index b287a940cc82..9a7c65ca2cf5 100644
--- a/test/std/strings/basic.string/string.cons/move_noexcept.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/move_noexcept.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <string>
 
 // basic_string(basic_string&&)
@@ -29,7 +31,6 @@ struct some_alloc
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::string C;
         static_assert(std::is_nothrow_move_constructible<C>::value, "");
@@ -46,5 +47,4 @@ int main()
         static_assert( std::is_nothrow_move_constructible<C>::value, "");
 #endif
     }
-#endif
 }
diff --git a/test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp b/test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp
index f6e9e00e590f..b678247fb241 100644
--- a/test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp
@@ -16,6 +16,7 @@
 #include <algorithm>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
@@ -28,7 +29,7 @@ test(const charT* s)
     typedef typename S::allocator_type A;
     unsigned n = T::length(s);
     S s2(s);
-    assert(s2.__invariants());
+    LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == n);
     assert(T::compare(s2.data(), s, n) == 0);
     assert(s2.get_allocator() == A());
@@ -43,7 +44,7 @@ test(const charT* s, const A& a)
     typedef typename S::traits_type T;
     unsigned n = T::length(s);
     S s2(s, a);
-    assert(s2.__invariants());
+    LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == n);
     assert(T::compare(s2.data(), s, n) == 0);
     assert(s2.get_allocator() == a);
@@ -68,7 +69,7 @@ int main()
     test("123456798012345679801234567980123456798012345679801234567980");
     test("123456798012345679801234567980123456798012345679801234567980", A(2));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef min_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
diff --git a/test/std/strings/basic.string/string.cons/pointer_assignment.pass.cpp b/test/std/strings/basic.string/string.cons/pointer_assignment.pass.cpp
index c691613379a2..506ab9374002 100644
--- a/test/std/strings/basic.string/string.cons/pointer_assignment.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/pointer_assignment.pass.cpp
@@ -15,6 +15,7 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -23,7 +24,7 @@ test(S s1, const typename S::value_type* s2)
 {
     typedef typename S::traits_type T;
     s1 = s2;
-    assert(s1.__invariants());
+    LIBCPP_ASSERT(s1.__invariants());
     assert(s1.size() == T::length(s2));
     assert(T::compare(s1.data(), s2, s1.size()) == 0);
     assert(s1.capacity() >= s1.size());
@@ -49,7 +50,7 @@ int main()
            "1234567890123456789012345678901234567890123456789012345678901234567890"),
          "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), "");
diff --git a/test/std/strings/basic.string/string.cons/pointer_size_alloc.pass.cpp b/test/std/strings/basic.string/string.cons/pointer_size_alloc.pass.cpp
index f1f107af20bb..bcab9eb6789e 100644
--- a/test/std/strings/basic.string/string.cons/pointer_size_alloc.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/pointer_size_alloc.pass.cpp
@@ -16,6 +16,7 @@
 #include <algorithm>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
@@ -27,7 +28,7 @@ test(const charT* s, unsigned n)
     typedef typename S::traits_type T;
     typedef typename S::allocator_type A;
     S s2(s, n);
-    assert(s2.__invariants());
+    LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == n);
     assert(T::compare(s2.data(), s, n) == 0);
     assert(s2.get_allocator() == A());
@@ -41,7 +42,7 @@ test(const charT* s, unsigned n, const A& a)
     typedef std::basic_string<charT, std::char_traits<charT>, A> S;
     typedef typename S::traits_type T;
     S s2(s, n, a);
-    assert(s2.__invariants());
+    LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == n);
     assert(T::compare(s2.data(), s, n) == 0);
     assert(s2.get_allocator() == a);
@@ -66,7 +67,7 @@ int main()
     test("123456798012345679801234567980123456798012345679801234567980", 60);
     test("123456798012345679801234567980123456798012345679801234567980", 60, A(2));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef min_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
diff --git a/test/std/strings/basic.string/string.cons/size_char_alloc.pass.cpp b/test/std/strings/basic.string/string.cons/size_char_alloc.pass.cpp
index 4dfe9063a23e..60d41b1d35be 100644
--- a/test/std/strings/basic.string/string.cons/size_char_alloc.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/size_char_alloc.pass.cpp
@@ -16,6 +16,7 @@
 #include <algorithm>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
@@ -27,7 +28,7 @@ test(unsigned n, charT c)
     typedef typename S::traits_type T;
     typedef typename S::allocator_type A;
     S s2(n, c);
-    assert(s2.__invariants());
+    LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == n);
     for (unsigned i = 0; i < n; ++i)
         assert(s2[i] == c);
@@ -42,7 +43,7 @@ test(unsigned n, charT c, const A& a)
     typedef std::basic_string<charT, std::char_traits<charT>, A> S;
     typedef typename S::traits_type T;
     S s2(n, c, a);
-    assert(s2.__invariants());
+    LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == n);
     for (unsigned i = 0; i < n; ++i)
         assert(s2[i] == c);
@@ -59,7 +60,7 @@ test(Tp n, Tp c)
     typedef typename S::traits_type T;
     typedef typename S::allocator_type A;
     S s2(n, c);
-    assert(s2.__invariants());
+    LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == n);
     for (unsigned i = 0; i < n; ++i)
         assert(s2[i] == c);
@@ -75,7 +76,7 @@ test(Tp n, Tp c, const A& a)
     typedef std::basic_string<charT, std::char_traits<charT>, A> S;
     typedef typename S::traits_type T;
     S s2(n, c, a);
-    assert(s2.__invariants());
+    LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == n);
     for (unsigned i = 0; i < n; ++i)
         assert(s2[i] == c);
@@ -104,7 +105,7 @@ int main()
     test(100, 65);
     test(100, 65, A(3));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef min_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
diff --git a/test/std/strings/basic.string/string.cons/substr.pass.cpp b/test/std/strings/basic.string/string.cons/substr.pass.cpp
index 2e42be13a842..a10239bb3414 100644
--- a/test/std/strings/basic.string/string.cons/substr.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/substr.pass.cpp
@@ -11,14 +11,21 @@
 // <string>
 
 // basic_string(const basic_string<charT,traits,Allocator>& str,
-//              size_type pos, size_type n = npos,
+//              size_type pos, size_type n,
+//              const Allocator& a = Allocator());
+//
+// basic_string(const basic_string<charT,traits,Allocator>& str,
+//              size_type pos,
 //              const Allocator& a = Allocator());
 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
+#include <vector>
+#include <scoped_allocator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
@@ -31,7 +38,7 @@ test(S str, unsigned pos)
     try
     {
         S s2(str, pos);
-        assert(s2.__invariants());
+        LIBCPP_ASSERT(s2.__invariants());
         assert(pos <= str.size());
         unsigned rlen = str.size() - pos;
         assert(s2.size() == rlen);
@@ -54,7 +61,7 @@ test(S str, unsigned pos, unsigned n)
     try
     {
         S s2(str, pos, n);
-        assert(s2.__invariants());
+        LIBCPP_ASSERT(s2.__invariants());
         assert(pos <= str.size());
         unsigned rlen = std::min<unsigned>(str.size() - pos, n);
         assert(s2.size() == rlen);
@@ -77,7 +84,7 @@ test(S str, unsigned pos, unsigned n, const typename S::allocator_type& a)
     try
     {
         S s2(str, pos, n, a);
-        assert(s2.__invariants());
+        LIBCPP_ASSERT(s2.__invariants());
         assert(pos <= str.size());
         unsigned rlen = std::min<unsigned>(str.size() - pos, n);
         assert(s2.size() == rlen);
@@ -91,6 +98,20 @@ test(S str, unsigned pos, unsigned n, const typename S::allocator_type& a)
     }
 }
 
+#if TEST_STD_VER >= 11
+void test2583()
+{   // LWG #2583
+    typedef std::basic_string<char, std::char_traits<char>, test_allocator<char> > StringA;
+    std::vector<StringA, std::scoped_allocator_adaptor<test_allocator<StringA>>> vs;
+    StringA s{"1234"};
+    vs.emplace_back(s, 2);
+
+    try { vs.emplace_back(s, 5); }
+    catch (const std::out_of_range&) { return; }
+    assert(false);
+}
+#endif
+
 int main()
 {
     {
@@ -131,7 +152,7 @@ int main()
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 10, A(8));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 100, A(8));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef min_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
@@ -170,5 +191,7 @@ int main()
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 10, A());
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 100, A());
     }
+
+    test2583();
 #endif
 }
diff --git a/test/std/strings/basic.string/string.iterators/begin.pass.cpp b/test/std/strings/basic.string/string.iterators/begin.pass.cpp
index 55f2eb30f80a..ea811113dfe9 100644
--- a/test/std/strings/basic.string/string.iterators/begin.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/begin.pass.cpp
@@ -38,7 +38,7 @@ int main()
     test(S());
     test(S("123"));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
diff --git a/test/std/strings/basic.string/string.iterators/cbegin.pass.cpp b/test/std/strings/basic.string/string.iterators/cbegin.pass.cpp
index d0c6ddbb9508..fb4b4bdc3d8e 100644
--- a/test/std/strings/basic.string/string.iterators/cbegin.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/cbegin.pass.cpp
@@ -35,7 +35,7 @@ int main()
     test(S());
     test(S("123"));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
diff --git a/test/std/strings/basic.string/string.iterators/cend.pass.cpp b/test/std/strings/basic.string/string.iterators/cend.pass.cpp
index 6b86d263245b..9ee56be783a2 100644
--- a/test/std/strings/basic.string/string.iterators/cend.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/cend.pass.cpp
@@ -31,7 +31,7 @@ int main()
     test(S());
     test(S("123"));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
diff --git a/test/std/strings/basic.string/string.iterators/crbegin.pass.cpp b/test/std/strings/basic.string/string.iterators/crbegin.pass.cpp
index 6f29f433f314..90988a39a35e 100644
--- a/test/std/strings/basic.string/string.iterators/crbegin.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/crbegin.pass.cpp
@@ -35,7 +35,7 @@ int main()
     test(S());
     test(S("123"));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
diff --git a/test/std/strings/basic.string/string.iterators/crend.pass.cpp b/test/std/strings/basic.string/string.iterators/crend.pass.cpp
index 1fb422c080ac..bb383787fe49 100644
--- a/test/std/strings/basic.string/string.iterators/crend.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/crend.pass.cpp
@@ -31,7 +31,7 @@ int main()
     test(S());
     test(S("123"));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
diff --git a/test/std/strings/basic.string/string.iterators/db_iterators_2.pass.cpp b/test/std/strings/basic.string/string.iterators/db_iterators_2.pass.cpp
index 6cac1875ce81..e46368c7717a 100644
--- a/test/std/strings/basic.string/string.iterators/db_iterators_2.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/db_iterators_2.pass.cpp
@@ -32,7 +32,7 @@ int main()
     bool b = s1.begin() < s2.begin();
     assert(false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S s1;
diff --git a/test/std/strings/basic.string/string.iterators/db_iterators_3.pass.cpp b/test/std/strings/basic.string/string.iterators/db_iterators_3.pass.cpp
index d90387e3a46d..3ed15d7c0c04 100644
--- a/test/std/strings/basic.string/string.iterators/db_iterators_3.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/db_iterators_3.pass.cpp
@@ -32,7 +32,7 @@ int main()
     int i = s1.begin() - s2.begin();
     assert(false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S s1;
diff --git a/test/std/strings/basic.string/string.iterators/db_iterators_4.pass.cpp b/test/std/strings/basic.string/string.iterators/db_iterators_4.pass.cpp
index c4a2d0a4baf6..85ea2201f2a0 100644
--- a/test/std/strings/basic.string/string.iterators/db_iterators_4.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/db_iterators_4.pass.cpp
@@ -33,7 +33,7 @@ int main()
     assert(i[1] == 0);
     assert(false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> C;
     C c(1, '\0');
diff --git a/test/std/strings/basic.string/string.iterators/db_iterators_5.pass.cpp b/test/std/strings/basic.string/string.iterators/db_iterators_5.pass.cpp
index ce44cb1ba5b4..9702090e41f8 100644
--- a/test/std/strings/basic.string/string.iterators/db_iterators_5.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/db_iterators_5.pass.cpp
@@ -35,7 +35,7 @@ int main()
     i += 2;
     assert(false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> C;
     C c(1, '\0');
diff --git a/test/std/strings/basic.string/string.iterators/db_iterators_6.pass.cpp b/test/std/strings/basic.string/string.iterators/db_iterators_6.pass.cpp
index 8fab8babc613..e42ba4cf15d7 100644
--- a/test/std/strings/basic.string/string.iterators/db_iterators_6.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/db_iterators_6.pass.cpp
@@ -34,7 +34,7 @@ int main()
     --i;
     assert(false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> C;
     C c(1, '\0');
diff --git a/test/std/strings/basic.string/string.iterators/db_iterators_7.pass.cpp b/test/std/strings/basic.string/string.iterators/db_iterators_7.pass.cpp
index d1cac07e222b..69a682142c14 100644
--- a/test/std/strings/basic.string/string.iterators/db_iterators_7.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/db_iterators_7.pass.cpp
@@ -34,7 +34,7 @@ int main()
     ++i;
     assert(false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> C;
     C c(1, '\0');
diff --git a/test/std/strings/basic.string/string.iterators/db_iterators_8.pass.cpp b/test/std/strings/basic.string/string.iterators/db_iterators_8.pass.cpp
index 914c77d48c5c..5472773e6dfe 100644
--- a/test/std/strings/basic.string/string.iterators/db_iterators_8.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/db_iterators_8.pass.cpp
@@ -32,7 +32,7 @@ int main()
     char j = *i;
     assert(false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> C;
     C c(1, '\0');
diff --git a/test/std/strings/basic.string/string.iterators/end.pass.cpp b/test/std/strings/basic.string/string.iterators/end.pass.cpp
index 02180bbd73de..abd0c2d853dc 100644
--- a/test/std/strings/basic.string/string.iterators/end.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/end.pass.cpp
@@ -40,7 +40,7 @@ int main()
     test(S());
     test(S("123"));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
diff --git a/test/std/strings/basic.string/string.iterators/iterators.pass.cpp b/test/std/strings/basic.string/string.iterators/iterators.pass.cpp
index 386cededa53f..9466f1135102 100644
--- a/test/std/strings/basic.string/string.iterators/iterators.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/iterators.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
+
 // <string>
 
 // iterator       begin();
@@ -21,7 +23,6 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     { // N3644 testing
         typedef std::string C;
         C::iterator ii1{}, ii2{};
@@ -40,7 +41,7 @@ int main()
         C::iterator ii4 = ii1;
         C::const_iterator cii{};
         assert ( ii1 == ii2 );
-        assert ( ii1 == ii4 );        
+        assert ( ii1 == ii4 );
         assert ( ii1 == cii );
         assert ( !(ii1 != ii2 ));
         assert ( !(ii1 != cii ));
@@ -69,5 +70,4 @@ int main()
         assert ( !(ii1 != ii2 ));
         assert ( !(ii1 != cii ));
     }
-#endif
 }
diff --git a/test/std/strings/basic.string/string.iterators/rbegin.pass.cpp b/test/std/strings/basic.string/string.iterators/rbegin.pass.cpp
index 0111ad113638..698d613ca6ad 100644
--- a/test/std/strings/basic.string/string.iterators/rbegin.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/rbegin.pass.cpp
@@ -38,7 +38,7 @@ int main()
     test(S());
     test(S("123"));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
diff --git a/test/std/strings/basic.string/string.iterators/rend.pass.cpp b/test/std/strings/basic.string/string.iterators/rend.pass.cpp
index 750173dc342e..c8c2d9ccadca 100644
--- a/test/std/strings/basic.string/string.iterators/rend.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/rend.pass.cpp
@@ -40,7 +40,7 @@ int main()
     test(S());
     test(S("123"));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
diff --git a/test/std/strings/basic.string/string.modifiers/string_append/initializer_list.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_append/initializer_list.pass.cpp
index 2abfbf0a172b..d30ca44695a8 100644
--- a/test/std/strings/basic.string/string.modifiers/string_append/initializer_list.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_append/initializer_list.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <string>
 
 // basic_string& append(initializer_list<charT> il);
@@ -14,23 +16,20 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     {
         std::string s("123");
         s.append({'a', 'b', 'c'});
         assert(s == "123abc");
     }
-#if TEST_STD_VER >= 11
     {
         typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
         S s("123");
         s.append({'a', 'b', 'c'});
         assert(s == "123abc");
     }
-#endif
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp
index 82e6fb5895e7..55fc63d06214 100644
--- a/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp
@@ -23,10 +23,11 @@ void
 test(S s, It first, It last, S expected)
 {
     s.append(first, last);
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
+#ifndef TEST_HAS_NO_EXCEPTIONS
 template <class S, class It>
 void
 test_exceptions(S s, It first, It last)
@@ -37,9 +38,10 @@ test_exceptions(S s, It first, It last)
     	assert(false);
     	}
     catch (...) {}
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s == aCopy);
 }
+#endif
 
 int main()
 {
@@ -161,6 +163,7 @@ int main()
          S("12345678901234567890""ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
     }
 #endif
+#ifndef TEST_HAS_NO_EXCEPTIONS
 	{ // test iterator operations that throw
     typedef std::string S;
     typedef ThrowingIterator<char> TIter;
@@ -174,4 +177,5 @@ int main()
     test_exceptions(S(), TIter(s, s+10, 5, TIter::TADereference), TIter());
     test_exceptions(S(), TIter(s, s+10, 6, TIter::TAComparison), TIter());
 	}
+#endif
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp
index c0413d607e8f..7c45068a53e1 100644
--- a/test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp
@@ -15,6 +15,7 @@
 #include <stdexcept>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -22,7 +23,7 @@ void
 test(S s, const typename S::value_type* str, S expected)
 {
     s.append(str);
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_append/pointer_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_append/pointer_size.pass.cpp
index f3ea3b0a89d7..6c594ebac3be 100644
--- a/test/std/strings/basic.string/string.modifiers/string_append/pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_append/pointer_size.pass.cpp
@@ -16,6 +16,7 @@
 #include <stdexcept>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -23,7 +24,7 @@ void
 test(S s, const typename S::value_type* str, typename S::size_type n, S expected)
 {
     s.append(str, n);
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_append/push_back.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_append/push_back.pass.cpp
index d6116d3f4823..f2fb8782a21d 100644
--- a/test/std/strings/basic.string/string.modifiers/string_append/push_back.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_append/push_back.pass.cpp
@@ -14,6 +14,7 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -21,7 +22,7 @@ void
 test(S s, typename S::value_type c, S expected)
 {
     s.push_back(c);
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_append/size_char.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_append/size_char.pass.cpp
index a049e6112a8a..1610ab5a17d1 100644
--- a/test/std/strings/basic.string/string.modifiers/string_append/size_char.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_append/size_char.pass.cpp
@@ -15,6 +15,7 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -22,7 +23,7 @@ void
 test(S s, typename S::size_type n, typename S::value_type c, S expected)
 {
     s.append(n, c);
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_append/string.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_append/string.pass.cpp
index e25627fa6a24..b58ed632893e 100644
--- a/test/std/strings/basic.string/string.modifiers/string_append/string.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_append/string.pass.cpp
@@ -15,6 +15,7 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -22,7 +23,7 @@ void
 test(S s, S str, S expected)
 {
     s.append(str);
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp
index d67b0304b41a..9e8158c3e43e 100644
--- a/test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp
@@ -18,6 +18,7 @@
 #include <stdexcept>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -27,7 +28,7 @@ test(S s, S str, typename S::size_type pos, typename S::size_type n, S expected)
     try
     {
         s.append(str, pos, n);
-        assert(s.__invariants());
+        LIBCPP_ASSERT(s.__invariants());
         assert(pos <= str.size());
         assert(s == expected);
     }
@@ -44,7 +45,7 @@ test_npos(S s, S str, typename S::size_type pos, S expected)
     try
     {
         s.append(str, pos);
-        assert(s.__invariants());
+        LIBCPP_ASSERT(s.__invariants());
         assert(pos <= str.size());
         assert(s == expected);
     }
diff --git a/test/std/strings/basic.string/string.modifiers/string_assign/initializer_list.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_assign/initializer_list.pass.cpp
index 003af0eef827..a2114cf5a83b 100644
--- a/test/std/strings/basic.string/string.modifiers/string_assign/initializer_list.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_assign/initializer_list.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <string>
 
 // basic_string& assign(initializer_list<charT> il);
@@ -14,23 +16,20 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     {
         std::string s("123");
         s.assign({'a', 'b', 'c'});
         assert(s == "abc");
     }
-#if TEST_STD_VER >= 11
     {
         typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
         S s("123");
         s.assign({'a', 'b', 'c'});
         assert(s == "abc");
     }
-#endif
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp
index 690aebd4c2a6..e6a57519f34b 100644
--- a/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp
@@ -15,6 +15,7 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 
@@ -23,10 +24,11 @@ void
 test(S s, It first, It last, S expected)
 {
     s.assign(first, last);
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
+#ifndef TEST_HAS_NO_EXCEPTIONS
 template <class S, class It>
 void
 test_exceptions(S s, It first, It last)
@@ -35,11 +37,12 @@ test_exceptions(S s, It first, It last)
     try {
    	    s.assign(first, last);
     	assert(false);
-    	}
+    }
     catch (...) {}
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s == aCopy);
 }
+#endif
 
 int main()
 {
@@ -101,7 +104,7 @@ int main()
     test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+52),
          S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
@@ -161,6 +164,7 @@ int main()
          S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
     }
 #endif
+#ifndef TEST_HAS_NO_EXCEPTIONS
 	{ // test iterator operations that throw
     typedef std::string S;
     typedef ThrowingIterator<char> TIter;
@@ -174,4 +178,5 @@ int main()
     test_exceptions(S(), TIter(s, s+10, 5, TIter::TADereference), TIter());
     test_exceptions(S(), TIter(s, s+10, 6, TIter::TAComparison), TIter());
 	}
+#endif
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_assign/pointer.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_assign/pointer.pass.cpp
index 07dbcea704dc..386dee6d5808 100644
--- a/test/std/strings/basic.string/string.modifiers/string_assign/pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_assign/pointer.pass.cpp
@@ -15,6 +15,7 @@
 #include <stdexcept>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -22,7 +23,7 @@ void
 test(S s, const typename S::value_type* str, S expected)
 {
     s.assign(str);
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp
index a9c71cec882b..0eeb9266f40f 100644
--- a/test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp
@@ -16,6 +16,7 @@
 #include <stdexcept>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -23,7 +24,7 @@ void
 test(S s, const typename S::value_type* str, typename S::size_type n, S expected)
 {
     s.assign(str, n);
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_assign/rv_string.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_assign/rv_string.pass.cpp
index b3d225a8d04a..6b89df98de72 100644
--- a/test/std/strings/basic.string/string.modifiers/string_assign/rv_string.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_assign/rv_string.pass.cpp
@@ -16,6 +16,7 @@
 #include <utility>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -23,7 +24,7 @@ void
 test(S s, S str, S expected)
 {
     s.assign(std::move(str));
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_assign/size_char.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_assign/size_char.pass.cpp
index 9dd19d877c90..a899e0dbe7b5 100644
--- a/test/std/strings/basic.string/string.modifiers/string_assign/size_char.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_assign/size_char.pass.cpp
@@ -15,6 +15,7 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -22,7 +23,7 @@ void
 test(S s, typename S::size_type n, typename S::value_type c, S expected)
 {
     s.assign(n, c);
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_assign/string.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_assign/string.pass.cpp
index 2bc5dd223e62..788512ba3d3e 100644
--- a/test/std/strings/basic.string/string.modifiers/string_assign/string.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_assign/string.pass.cpp
@@ -15,17 +15,29 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 void
 test(S s, S str, S expected)
 {
     s.assign(str);
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
+template <class S>
+void
+testAlloc(S s, S str, const typename S::allocator_type& a)
+{
+    s.assign(str);
+    LIBCPP_ASSERT(s.__invariants());
+    assert(s == str);
+    assert(s.get_allocator() == a);
+}
+
 int main()
 {
     {
@@ -50,7 +62,22 @@ int main()
     test(S("12345678901234567890"), S("1234567890"), S("1234567890"));
     test(S("12345678901234567890"), S("12345678901234567890"),
          S("12345678901234567890"));
+
+    testAlloc(S(), S(), std::allocator<char>());
+    testAlloc(S(), S("12345"), std::allocator<char>());
+    testAlloc(S(), S("1234567890"), std::allocator<char>());
+    testAlloc(S(), S("12345678901234567890"), std::allocator<char>());
+    }
+
+    { //  LWG#5579 make sure assign takes the allocators where appropriate
+    typedef other_allocator<char> A;  // has POCCA --> true
+    typedef std::basic_string<char, std::char_traits<char>, A> S;
+    testAlloc(S(A(5)), S(A(3)), A(3));
+    testAlloc(S(A(5)), S("1"), A());
+    testAlloc(S(A(5)), S("1", A(7)), A(7));
+    testAlloc(S(A(5)), S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), A(7));
     }
+
 #if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
@@ -74,9 +101,14 @@ int main()
     test(S("12345678901234567890"), S("1234567890"), S("1234567890"));
     test(S("12345678901234567890"), S("12345678901234567890"),
          S("12345678901234567890"));
+
+    testAlloc(S(), S(), min_allocator<char>());
+    testAlloc(S(), S("12345"), min_allocator<char>());
+    testAlloc(S(), S("1234567890"), min_allocator<char>());
+    testAlloc(S(), S("12345678901234567890"), min_allocator<char>());
     }
 #endif
-#if __cplusplus > 201402L
+#if TEST_STD_VER > 14
     {
     typedef std::string S;
     static_assert(noexcept(S().assign(S())), "");  // LWG#2063
diff --git a/test/std/strings/basic.string/string.modifiers/string_assign/string_size_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_assign/string_size_size.pass.cpp
index 275d249d304c..d9d3cb422ae5 100644
--- a/test/std/strings/basic.string/string.modifiers/string_assign/string_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_assign/string_size_size.pass.cpp
@@ -18,6 +18,7 @@
 #include <stdexcept>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -27,7 +28,7 @@ test(S s, S str, typename S::size_type pos, typename S::size_type n, S expected)
     try
     {
         s.assign(str, pos, n);
-        assert(s.__invariants());
+        LIBCPP_ASSERT(s.__invariants());
         assert(pos <= str.size());
         assert(s == expected);
     }
@@ -44,7 +45,7 @@ test_npos(S s, S str, typename S::size_type pos, S expected)
     try
     {
         s.assign(str, pos);
-        assert(s.__invariants());
+        LIBCPP_ASSERT(s.__invariants());
         assert(pos <= str.size());
         assert(s == expected);
     }
diff --git a/test/std/strings/basic.string/string.modifiers/string_copy/copy.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_copy/copy.pass.cpp
index 69f001cf4f00..b66877652837 100644
--- a/test/std/strings/basic.string/string.modifiers/string_copy/copy.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_copy/copy.pass.cpp
@@ -17,6 +17,7 @@
 #include <algorithm>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -104,7 +105,7 @@ int main()
     test(S("abcdefghijklmnopqrst"), s, 20, 1);
     test(S("abcdefghijklmnopqrst"), s, 21, 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     char s[50];
diff --git a/test/std/strings/basic.string/string.modifiers/string_erase/iter.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_erase/iter.pass.cpp
index c44db71ae3b0..8de5fc7bab85 100644
--- a/test/std/strings/basic.string/string.modifiers/string_erase/iter.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_erase/iter.pass.cpp
@@ -14,6 +14,7 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -22,7 +23,7 @@ test(S s, typename S::difference_type pos, S expected)
 {
     typename S::const_iterator p = s.begin() + pos;
     typename S::iterator i = s.erase(p);
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
     assert(i - s.begin() == pos);
 }
@@ -44,7 +45,7 @@ int main()
     test(S("abcdefghijklmnopqrst"), 10, S("abcdefghijlmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 19, S("abcdefghijklmnopqrs"));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S("abcde"), 0, S("bcde"));
diff --git a/test/std/strings/basic.string/string.modifiers/string_erase/iter_iter.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_erase/iter_iter.pass.cpp
index dbe6d7ba0e73..e4fe2cdfd022 100644
--- a/test/std/strings/basic.string/string.modifiers/string_erase/iter_iter.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_erase/iter_iter.pass.cpp
@@ -14,6 +14,7 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -23,7 +24,7 @@ test(S s, typename S::difference_type pos, typename S::difference_type n, S expe
     typename S::const_iterator first = s.cbegin() + pos;
     typename S::const_iterator last = s.cbegin() + pos + n;
     typename S::iterator i = s.erase(first, last);
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
     assert(i - s.begin() == pos);
 }
@@ -87,7 +88,7 @@ int main()
     test(S("abcdefghijklmnopqrst"), 19, 1, S("abcdefghijklmnopqrs"));
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghijklmnopqrst"));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 0, 0, S(""));
diff --git a/test/std/strings/basic.string/string.modifiers/string_erase/pop_back.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_erase/pop_back.pass.cpp
index 790ce40b0a00..64f8e506b13e 100644
--- a/test/std/strings/basic.string/string.modifiers/string_erase/pop_back.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_erase/pop_back.pass.cpp
@@ -11,13 +11,10 @@
 
 // void pop_back();
 
-#if _LIBCPP_DEBUG >= 1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
-#endif
-
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -25,7 +22,7 @@ void
 test(S s, S expected)
 {
     s.pop_back();
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
@@ -37,7 +34,7 @@ int main()
     test(S("abcdefghij"), S("abcdefghi"));
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrs"));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S("abcde"), S("abcd"));
@@ -45,11 +42,4 @@ int main()
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrs"));
     }
 #endif
-#if _LIBCPP_DEBUG >= 1
-    {
-        std::string s;
-        s.pop_back();
-        assert(false);
-    }
-#endif        
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_erase/size_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_erase/size_size.pass.cpp
index 11015cb973ed..5db97ec2cf5f 100644
--- a/test/std/strings/basic.string/string.modifiers/string_erase/size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_erase/size_size.pass.cpp
@@ -17,6 +17,7 @@
 #include <stdexcept>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -28,7 +29,7 @@ test(S s, typename S::size_type pos, typename S::size_type n, S expected)
     try
     {
         s.erase(pos, n);
-        assert(s.__invariants());
+        LIBCPP_ASSERT(s.__invariants());
         assert(pos <= old_size);
         assert(s == expected);
     }
@@ -48,7 +49,7 @@ test(S s, typename S::size_type pos, S expected)
     try
     {
         s.erase(pos);
-        assert(s.__invariants());
+        LIBCPP_ASSERT(s.__invariants());
         assert(pos <= old_size);
         assert(s == expected);
     }
@@ -64,7 +65,7 @@ void
 test(S s, S expected)
 {
     s.erase();
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
@@ -173,7 +174,7 @@ int main()
     test(S("abcdefghij"), S(""));
     test(S("abcdefghijklmnopqrst"), S(""));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 0, 0, S(""));
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/iter_char.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/iter_char.pass.cpp
index 6b0a3aa006ee..6bd9b7e01c37 100644
--- a/test/std/strings/basic.string/string.modifiers/string_insert/iter_char.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/iter_char.pass.cpp
@@ -11,14 +11,11 @@
 
 // iterator insert(const_iterator p, charT c);
 
-#if _LIBCPP_DEBUG >= 1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
-#endif
-
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -28,7 +25,7 @@ test(S& s, typename S::const_iterator p, typename S::value_type c, S expected)
     bool sufficient_cap = s.size() < s.capacity();
     typename S::difference_type pos = p - s.begin();
     typename S::iterator i = s.insert(p, c);
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
     assert(i - s.begin() == pos);
     assert(*i == c);
@@ -76,13 +73,4 @@ int main()
     test(s, s.begin()+6, 'C', S("a567ABC1432dcb"));
     }
 #endif
-#if _LIBCPP_DEBUG >= 1
-    {
-        typedef std::string S;
-        S s;
-        S s2;
-        s.insert(s2.begin(), '1');
-        assert(false);
-    }
-#endif
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp
index 4c29ab4ed093..bbae39419da4 100644
--- a/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp
@@ -28,11 +28,12 @@ test(S s, typename S::difference_type pos, It first, It last, S expected)
 {
     typename S::const_iterator p = s.cbegin() + pos;
     typename S::iterator i = s.insert(p, first, last);
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(i - s.begin() == pos);
     assert(s == expected);
 }
 
+#ifndef TEST_HAS_NO_EXCEPTIONS
 template <class S, class It>
 void
 test_exceptions(S s, typename S::difference_type pos, It first, It last)
@@ -44,9 +45,10 @@ test_exceptions(S s, typename S::difference_type pos, It first, It last)
         assert(false);
         }
     catch (...) {}
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s == aCopy);
 }
+#endif
 
 int main()
 {
@@ -142,6 +144,7 @@ int main()
          S("12345678901234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
     }
 #endif
+#ifndef TEST_HAS_NO_EXCEPTIONS
 	{ // test iterator operations that throw
     typedef std::string S;
     typedef ThrowingIterator<char> TIter;
@@ -155,6 +158,7 @@ int main()
     test_exceptions(S(), 0, TIter(s, s+10, 5, TIter::TADereference), TIter());
     test_exceptions(S(), 0, TIter(s, s+10, 6, TIter::TAComparison), TIter());
 	}
+#endif
 #if _LIBCPP_DEBUG >= 1
     {
         std::string v;
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/iter_size_char.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/iter_size_char.pass.cpp
index e6d1db6fc0df..c9cd0c2c9248 100644
--- a/test/std/strings/basic.string/string.modifiers/string_insert/iter_size_char.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/iter_size_char.pass.cpp
@@ -11,13 +11,10 @@
 
 // iterator insert(const_iterator p, size_type n, charT c);
 
-#if _LIBCPP_DEBUG >= 1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
-#endif
-
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -27,7 +24,7 @@ test(S s, typename S::difference_type pos, typename S::size_type n,
 {
     typename S::const_iterator p = s.cbegin() + pos;
     typename S::iterator i = s.insert(p, n, c);
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(i - s.begin() == pos);
     assert(s == expected);
 }
@@ -170,12 +167,4 @@ int main()
     test(S("abcdefghijklmnopqrst"), 20, 20, '1', S("abcdefghijklmnopqrst11111111111111111111"));
     }
 #endif
-#if _LIBCPP_DEBUG >= 1
-    {
-        std::string s;
-        std::string s2;
-        s.insert(s2.begin(), 1, 'a');
-        assert(false);
-    }
-#endif
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp
index 247b3308f96e..faab5bd92672 100644
--- a/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp
@@ -17,6 +17,7 @@
 #include <stdexcept>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -28,7 +29,7 @@ test(S s, typename S::size_type pos, const typename S::value_type* str, S expect
     try
     {
         s.insert(pos, str);
-        assert(s.__invariants());
+        LIBCPP_ASSERT(s.__invariants());
         assert(pos <= old_size);
         assert(s == expected);
     }
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp
index 41b81231075e..30d3df9f259f 100644
--- a/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp
@@ -17,6 +17,7 @@
 #include <stdexcept>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -29,7 +30,7 @@ test(S s, typename S::size_type pos, const typename S::value_type* str,
     try
     {
         s.insert(pos, str, n);
-        assert(s.__invariants());
+        LIBCPP_ASSERT(s.__invariants());
         assert(pos <= old_size);
         assert(s == expected);
     }
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp
index 945ec48012ba..04ea1d376940 100644
--- a/test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp
@@ -17,6 +17,7 @@
 #include <stdexcept>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -29,7 +30,7 @@ test(S s, typename S::size_type pos, typename S::size_type n,
     try
     {
         s.insert(pos, n, str);
-        assert(s.__invariants());
+        LIBCPP_ASSERT(s.__invariants());
         assert(pos <= old_size);
         assert(s == expected);
     }
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/size_string.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/size_string.pass.cpp
index 04b47ec78988..1945871b99ac 100644
--- a/test/std/strings/basic.string/string.modifiers/string_insert/size_string.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/size_string.pass.cpp
@@ -17,6 +17,7 @@
 #include <stdexcept>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -28,7 +29,7 @@ test(S s, typename S::size_type pos, S str, S expected)
     try
     {
         s.insert(pos, str);
-        assert(s.__invariants());
+        LIBCPP_ASSERT(s.__invariants());
         assert(pos <= old_size);
         assert(s == expected);
     }
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp
index c3745c3749db..32485db478d8 100644
--- a/test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp
@@ -19,6 +19,7 @@
 #include <stdexcept>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -31,7 +32,7 @@ test(S s, typename S::size_type pos1, S str, typename S::size_type pos2,
     try
     {
         s.insert(pos1, str, pos2, n);
-        assert(s.__invariants());
+        LIBCPP_ASSERT(s.__invariants());
         assert(pos1 <= old_size && pos2 <= str.size());
         assert(s == expected);
     }
@@ -51,7 +52,7 @@ test_npos(S s, typename S::size_type pos1, S str, typename S::size_type pos2, S
     try
     {
         s.insert(pos1, str, pos2);
-        assert(s.__invariants());
+        LIBCPP_ASSERT(s.__invariants());
         assert(pos1 <= old_size && pos2 <= str.size());
         assert(s == expected);
     }
diff --git a/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/char.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/char.pass.cpp
index 7384ae7f1d3c..f39ed036e149 100644
--- a/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/char.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/char.pass.cpp
@@ -14,6 +14,7 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -21,7 +22,7 @@ void
 test(S s, typename S::value_type str, S expected)
 {
     s += str;
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
@@ -34,7 +35,7 @@ int main()
     test(S("1234567890"), 'a', S("1234567890a"));
     test(S("12345678901234567890"), 'a', S("12345678901234567890a"));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), 'a', S("a"));
diff --git a/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/initializer_list.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/initializer_list.pass.cpp
index c291028998df..5b32af951624 100644
--- a/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/initializer_list.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/initializer_list.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <string>
 
 // basic_string& operator+=(initializer_list<charT> il);
@@ -18,19 +20,15 @@
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     {
         std::string s("123");
         s += {'a', 'b', 'c'};
         assert(s == "123abc");
     }
-#if __cplusplus >= 201103L
     {
         typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
         S s("123");
         s += {'a', 'b', 'c'};
         assert(s == "123abc");
     }
-#endif
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/pointer.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/pointer.pass.cpp
index 77b20d1bc080..c19fd2909011 100644
--- a/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/pointer.pass.cpp
@@ -14,6 +14,7 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -21,7 +22,7 @@ void
 test(S s, const typename S::value_type* str, S expected)
 {
     s += str;
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
@@ -50,7 +51,7 @@ int main()
     test(S("12345678901234567890"), "12345678901234567890",
          S("1234567890123456789012345678901234567890"));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), "", S());
diff --git a/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/string.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/string.pass.cpp
index 33649792521c..1064855c1506 100644
--- a/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/string.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/string.pass.cpp
@@ -15,6 +15,7 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -22,7 +23,7 @@ void
 test(S s, S str, S expected)
 {
     s += str;
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
@@ -51,7 +52,7 @@ int main()
     test(S("12345678901234567890"), S("12345678901234567890"),
          S("1234567890123456789012345678901234567890"));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), S(), S());
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp
index 057964112aa1..cc37e79c7932 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp
@@ -29,12 +29,13 @@ test(S s, typename S::size_type pos1, typename S::size_type n1, It f, It l, S ex
     typename S::const_iterator last = s.begin() + pos1 + n1;
     typename S::size_type xlen = last - first;
     s.replace(first, last, f, l);
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
     typename S::size_type rlen = std::distance(f, l);
     assert(s.size() == old_size - xlen + rlen);
 }
 
+#ifndef TEST_HAS_NO_EXCEPTIONS
 template <class S, class It>
 void
 test_exceptions(S s, typename S::size_type pos1, typename S::size_type n1, It f, It l)
@@ -47,9 +48,10 @@ test_exceptions(S s, typename S::size_type pos1, typename S::size_type n1, It f,
 	    assert(false);
 	    }
 	catch (...) {}
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s == aCopy);
 }
+#endif
 
 const char* str = "12345678901234567890";
 
@@ -990,6 +992,7 @@ int main()
     test8<S>();
     }
 #endif
+#ifndef TEST_HAS_NO_EXCEPTIONS
 	{ // test iterator operations that throw
     typedef std::string S;
     typedef ThrowingIterator<char> TIter;
@@ -1003,4 +1006,5 @@ int main()
     test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, TIter(s, s+10, 5, TIter::TADereference), TIter());
     test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, TIter(s, s+10, 6, TIter::TAComparison), TIter());
 	}
+#endif
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer.pass.cpp
index c7551b928ec1..730fc1a501cf 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer.pass.cpp
@@ -29,7 +29,7 @@ test(S s, typename S::size_type pos1, typename S::size_type n1, const typename S
     typename S::const_iterator last = s.begin() + pos1 + n1;
     typename S::size_type xlen = last - first;
     s.replace(first, last, str);
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
     typename S::size_type rlen = S::traits_type::length(str);
     assert(s.size() == old_size - xlen + rlen);
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp
index 087df7824ac2..4a910e499819 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp
@@ -12,12 +12,11 @@
 // basic_string<charT,traits,Allocator>&
 //   replace(const_iterator i1, const_iterator i2, const charT* s, size_type n);
 
-#include <stdio.h>
-
 #include <string>
 #include <algorithm>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -30,7 +29,7 @@ test(S s, typename S::size_type pos1, typename S::size_type n1, const typename S
     typename S::const_iterator last = s.begin() + pos1 + n1;
     typename S::size_type xlen = last - first;
     s.replace(first, last, str, n2);
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
     typename S::size_type rlen = n2;
     assert(s.size() == old_size - xlen + rlen);
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_size_char.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_size_char.pass.cpp
index 8be8b5298237..4dbc8ab1f22c 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_size_char.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_size_char.pass.cpp
@@ -12,12 +12,11 @@
 // basic_string<charT,traits,Allocator>&
 //   replace(const_iterator i1, const_iterator i2, size_type n, charT c);
 
-#include <stdio.h>
-
 #include <string>
 #include <algorithm>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -30,7 +29,7 @@ test(S s, typename S::size_type pos1, typename S::size_type n1, typename S::size
     typename S::const_iterator last = s.begin() + pos1 + n1;
     typename S::size_type xlen = last - first;
     s.replace(first, last, n2, c);
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
     typename S::size_type rlen = n2;
     assert(s.size() == old_size - xlen + rlen);
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string.pass.cpp
index b85a1063ebe1..190e10d5c830 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string.pass.cpp
@@ -12,12 +12,11 @@
 // basic_string<charT,traits,Allocator>&
 //   replace(const_iterator i1, const_iterator i2, const basic_string& str);
 
-#include <stdio.h>
-
 #include <string>
 #include <algorithm>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -29,7 +28,7 @@ test(S s, typename S::size_type pos1, typename S::size_type n1, S str, S expecte
     typename S::const_iterator last = s.begin() + pos1 + n1;
     typename S::size_type xlen = last - first;
     s.replace(first, last, str);
-    assert(s.__invariants());
+    LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
     typename S::size_type rlen = str.size();
     assert(s.size() == old_size - xlen + rlen);
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer.pass.cpp
index eb0e982ef16e..3beb074c0fd3 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer.pass.cpp
@@ -13,13 +13,12 @@
 // basic_string<charT,traits,Allocator>&
 //   replace(size_type pos, size_type n1, const charT* s);
 
-#include <stdio.h>
-
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -32,7 +31,7 @@ test(S s, typename S::size_type pos, typename S::size_type n1,
     try
     {
         s.replace(pos, n1, str);
-        assert(s.__invariants());
+        LIBCPP_ASSERT(s.__invariants());
         assert(pos <= old_size);
         assert(s == expected);
         typename S::size_type xlen = std::min(n1, old_size - pos);
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer_size.pass.cpp
index 898ab2a144c1..d961e9e8f76f 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer_size.pass.cpp
@@ -13,13 +13,12 @@
 // basic_string<charT,traits,Allocator>&
 //   replace(size_type pos, size_type n1, const charT* s, size_type n2);
 
-#include <stdio.h>
-
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -33,7 +32,7 @@ test(S s, typename S::size_type pos, typename S::size_type n1,
     try
     {
         s.replace(pos, n1, str, n2);
-        assert(s.__invariants());
+        LIBCPP_ASSERT(s.__invariants());
         assert(pos <= old_size);
         assert(s == expected);
         typename S::size_type xlen = std::min(n1, old_size - pos);
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_size_char.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_size_char.pass.cpp
index e616ecc04261..d4696fba8a83 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_size_char.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_size_char.pass.cpp
@@ -18,6 +18,7 @@
 #include <algorithm>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -31,7 +32,7 @@ test(S s, typename S::size_type pos, typename S::size_type n1,
     try
     {
         s.replace(pos, n1, n2, c);
-        assert(s.__invariants());
+        LIBCPP_ASSERT(s.__invariants());
         assert(pos <= old_size);
         assert(s == expected);
         typename S::size_type xlen = std::min(n1, old_size - pos);
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string.pass.cpp
index ea311dd1564f..1be45d8a6624 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string.pass.cpp
@@ -18,6 +18,7 @@
 #include <algorithm>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -29,7 +30,7 @@ test(S s, typename S::size_type pos1, typename S::size_type n1, S str, S expecte
     try
     {
         s.replace(pos1, n1, str);
-        assert(s.__invariants());
+        LIBCPP_ASSERT(s.__invariants());
         assert(pos1 <= old_size);
         assert(s == expected);
         typename S::size_type xlen = std::min(n1, old_size - pos1);
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp
index 01f4a1f6ccef..3f4bf450d858 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp
@@ -20,6 +20,7 @@
 #include <algorithm>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -33,7 +34,7 @@ test(S s, typename S::size_type pos1, typename S::size_type n1,
     try
     {
         s.replace(pos1, n1, str, pos2, n2);
-        assert(s.__invariants());
+        LIBCPP_ASSERT(s.__invariants());
         assert(pos1 <= old_size && pos2 <= str.size());
         assert(s == expected);
         typename S::size_type xlen = std::min(n1, old_size - pos1);
@@ -58,7 +59,7 @@ test_npos(S s, typename S::size_type pos1, typename S::size_type n1,
     try
     {
         s.replace(pos1, n1, str, pos2);
-        assert(s.__invariants());
+        LIBCPP_ASSERT(s.__invariants());
         assert(pos1 <= old_size && pos2 <= str.size());
         assert(s == expected);
         typename S::size_type xlen = std::min(n1, old_size - pos1);
diff --git a/test/std/strings/basic.string/string.modifiers/string_swap/swap.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_swap/swap.pass.cpp
index 4973bda4ddf0..fe2ee1fa6da9 100644
--- a/test/std/strings/basic.string/string.modifiers/string_swap/swap.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_swap/swap.pass.cpp
@@ -16,6 +16,7 @@
 #include <algorithm>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -25,8 +26,8 @@ test(S s1, S s2)
     S s1_ = s1;
     S s2_ = s2;
     s1.swap(s2);
-    assert(s1.__invariants());
-    assert(s2.__invariants());
+    LIBCPP_ASSERT(s1.__invariants());
+    LIBCPP_ASSERT(s2.__invariants());
     assert(s1 == s2_);
     assert(s2 == s1_);
 }
@@ -52,7 +53,7 @@ int main()
     test(S("abcdefghijklmnopqrst"), S("1234567890"));
     test(S("abcdefghijklmnopqrst"), S("12345678901234567890"));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), S(""));
diff --git a/test/std/strings/basic.string/string.nonmembers/string.io/get_line.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string.io/get_line.pass.cpp
index 4a912eaec6fa..6011ea1586fc 100644
--- a/test/std/strings/basic.string/string.nonmembers/string.io/get_line.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string.io/get_line.pass.cpp
@@ -48,7 +48,7 @@ int main()
         assert(in.eof());
         assert(s == L"   ghij");
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
         std::istringstream in(" abc\n  def\n   ghij");
diff --git a/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim.pass.cpp
index 6596f2fffa79..79852337a033 100644
--- a/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim.pass.cpp
@@ -54,7 +54,7 @@ int main()
         assert(in.eof());
         assert(s == L"   ghij");
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
         std::istringstream in(" abc*  def**   ghij");
diff --git a/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim_rv.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim_rv.pass.cpp
index 84f52bb2e50f..48d1854808c0 100644
--- a/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim_rv.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim_rv.pass.cpp
@@ -33,7 +33,7 @@ int main()
         getline(std::wistringstream(L" abc*  def*   ghij"), s, L'*');
         assert(s == L" abc");
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
         S s("initial text");
diff --git a/test/std/strings/basic.string/string.nonmembers/string.io/get_line_rv.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string.io/get_line_rv.pass.cpp
index a3c9911abe9b..18c22f915ca0 100644
--- a/test/std/strings/basic.string/string.nonmembers/string.io/get_line_rv.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string.io/get_line_rv.pass.cpp
@@ -33,7 +33,7 @@ int main()
         getline(std::wistringstream(L" abc\n  def\n   ghij"), s);
         assert(s == L" abc");
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
         S s("initial text");
diff --git a/test/std/strings/basic.string/string.nonmembers/string.io/stream_extract.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string.io/stream_extract.pass.cpp
index af806bc04570..30e7dc6c12e0 100644
--- a/test/std/strings/basic.string/string.nonmembers/string.io/stream_extract.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string.io/stream_extract.pass.cpp
@@ -66,7 +66,7 @@ int main()
         in >> s;
         assert(in.fail());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
         std::istringstream in("a bc defghij");
diff --git a/test/std/strings/basic.string/string.nonmembers/string.io/stream_insert.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string.io/stream_insert.pass.cpp
index 102e8ea08159..6489ddfca466 100644
--- a/test/std/strings/basic.string/string.nonmembers/string.io/stream_insert.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string.io/stream_insert.pass.cpp
@@ -52,7 +52,7 @@ int main()
         assert(out.good());
         assert(L"   " + s == out.str());
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
         typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
         std::basic_ostringstream<S::value_type, S::traits_type, S::allocator_type> out;
diff --git a/test/std/strings/basic.string/string.nonmembers/string.special/swap.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string.special/swap.pass.cpp
index cee538800dd0..a2e25196d26f 100644
--- a/test/std/strings/basic.string/string.nonmembers/string.special/swap.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string.special/swap.pass.cpp
@@ -18,6 +18,7 @@
 #include <algorithm>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -27,8 +28,8 @@ test(S s1, S s2)
     S s1_ = s1;
     S s2_ = s2;
     swap(s1, s2);
-    assert(s1.__invariants());
-    assert(s2.__invariants());
+    LIBCPP_ASSERT(s1.__invariants());
+    LIBCPP_ASSERT(s2.__invariants());
     assert(s1 == s2_);
     assert(s2 == s1_);
 }
@@ -54,7 +55,7 @@ int main()
     test(S("abcdefghijklmnopqrst"), S("1234567890"));
     test(S("abcdefghijklmnopqrst"), S("12345678901234567890"));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), S(""));
diff --git a/test/std/strings/basic.string/string.nonmembers/string.special/swap_noexcept.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string.special/swap_noexcept.pass.cpp
index cfe03655a8a1..4ac13d10e670 100644
--- a/test/std/strings/basic.string/string.nonmembers/string.special/swap_noexcept.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string.special/swap_noexcept.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <string>
 
 // void swap(basic_string& c)
@@ -22,13 +24,14 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_allocator.h"
 
 template <class T>
 struct some_alloc
 {
     typedef T value_type;
-    
+
     some_alloc() {}
     some_alloc(const some_alloc&);
     void deallocate(void*, unsigned) {}
@@ -40,7 +43,7 @@ template <class T>
 struct some_alloc2
 {
     typedef T value_type;
-    
+
     some_alloc2() {}
     some_alloc2(const some_alloc2&);
     void deallocate(void*, unsigned) {}
@@ -51,7 +54,6 @@ struct some_alloc2
 
 int main()
 {
-#if __has_feature(cxx_noexcept)
     {
         typedef std::string C;
         C c1, c2;
@@ -80,6 +82,4 @@ int main()
         static_assert( noexcept(swap(c1, c2)), "");
     }
 #endif
-
-#endif
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_op!=/pointer_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_op!=/pointer_string.pass.cpp
index cc08982a5ca3..6d39d025c585 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_op!=/pointer_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_op!=/pointer_string.pass.cpp
@@ -45,7 +45,7 @@ int main()
     test("abcdefghijklmnopqrst", S("abcdefghij"), true);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test("", S(""), false);
diff --git a/test/std/strings/basic.string/string.nonmembers/string_op!=/string_pointer.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_op!=/string_pointer.pass.cpp
index b496d70dc2f0..67d18b7a9ca7 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_op!=/string_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_op!=/string_pointer.pass.cpp
@@ -45,7 +45,7 @@ int main()
     test(S("abcdefghijklmnopqrst"), "abcdefghij", true);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), "", false);
diff --git a/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string.pass.cpp
index 069b305111d4..27e97788c637 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string.pass.cpp
@@ -46,7 +46,7 @@ int main()
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), S(""), false);
diff --git a/test/std/strings/basic.string/string.nonmembers/string_op+/char_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_op+/char_string.pass.cpp
index 23a89c6fc8fb..9a8213e230fb 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_op+/char_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_op+/char_string.pass.cpp
@@ -49,7 +49,7 @@ int main()
     test0('a', S("12345"), S("a12345"));
     test0('a', S("1234567890"), S("a1234567890"));
     test0('a', S("12345678901234567890"), S("a12345678901234567890"));
-    
+
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     test1('a', S(""), S("a"));
@@ -59,14 +59,14 @@ int main()
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0('a', S(""), S("a"));
     test0('a', S("12345"), S("a12345"));
     test0('a', S("1234567890"), S("a1234567890"));
     test0('a', S("12345678901234567890"), S("a12345678901234567890"));
-    
+
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     test1('a', S(""), S("a"));
diff --git a/test/std/strings/basic.string/string.nonmembers/string_op+/pointer_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_op+/pointer_string.pass.cpp
index 665e86f2c239..88fa678ec44f 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_op+/pointer_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_op+/pointer_string.pass.cpp
@@ -83,7 +83,7 @@ int main()
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0("", S(""), S(""));
diff --git a/test/std/strings/basic.string/string.nonmembers/string_op+/string_char.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_op+/string_char.pass.cpp
index 12903fe8118e..b4c2c97043cc 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_op+/string_char.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_op+/string_char.pass.cpp
@@ -59,7 +59,7 @@ int main()
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0(S(""), '1', S("1"));
diff --git a/test/std/strings/basic.string/string.nonmembers/string_op+/string_pointer.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_op+/string_pointer.pass.cpp
index 63a7b769b787..3b669e7d9869 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_op+/string_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_op+/string_pointer.pass.cpp
@@ -83,7 +83,7 @@ int main()
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0(S(""), "", S(""));
diff --git a/test/std/strings/basic.string/string.nonmembers/string_op+/string_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_op+/string_string.pass.cpp
index 318b648d6eb0..1977b6f517ba 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_op+/string_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_op+/string_string.pass.cpp
@@ -143,7 +143,7 @@ int main()
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0(S(""), S(""), S(""));
diff --git a/test/std/strings/basic.string/string.nonmembers/string_operator==/pointer_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_operator==/pointer_string.pass.cpp
index 19a5bdd977e4..19dd8bfbd92e 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_operator==/pointer_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_operator==/pointer_string.pass.cpp
@@ -45,7 +45,7 @@ int main()
     test("abcdefghijklmnopqrst", S("abcdefghij"), false);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test("", S(""), true);
diff --git a/test/std/strings/basic.string/string.nonmembers/string_operator==/string_pointer.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_operator==/string_pointer.pass.cpp
index 22006bb1be68..f6e3ddec46e2 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_operator==/string_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_operator==/string_pointer.pass.cpp
@@ -45,7 +45,7 @@ int main()
     test(S("abcdefghijklmnopqrst"), "abcdefghij", false);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), "", true);
diff --git a/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string.pass.cpp
index 0bff70a977a6..c1d57b0bcc8b 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string.pass.cpp
@@ -46,7 +46,7 @@ int main()
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), S(""), true);
diff --git a/test/std/strings/basic.string/string.nonmembers/string_opgt/pointer_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_opgt/pointer_string.pass.cpp
index f9fa204b9eea..363e6d36100b 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_opgt/pointer_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_opgt/pointer_string.pass.cpp
@@ -45,7 +45,7 @@ int main()
     test("abcdefghijklmnopqrst", S("abcdefghij"), true);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test("", S(""), false);
diff --git a/test/std/strings/basic.string/string.nonmembers/string_opgt/string_pointer.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_opgt/string_pointer.pass.cpp
index daa6f40ae3c0..4b5f7c3689a2 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_opgt/string_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_opgt/string_pointer.pass.cpp
@@ -45,7 +45,7 @@ int main()
     test(S("abcdefghijklmnopqrst"), "abcdefghij", true);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), "", false);
diff --git a/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string.pass.cpp
index 95073bf7644c..01c7c5311b95 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string.pass.cpp
@@ -46,7 +46,7 @@ int main()
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), S(""), false);
diff --git a/test/std/strings/basic.string/string.nonmembers/string_opgt=/pointer_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_opgt=/pointer_string.pass.cpp
index eab117a843fa..f4ab04d60d8a 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_opgt=/pointer_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_opgt=/pointer_string.pass.cpp
@@ -45,7 +45,7 @@ int main()
     test("abcdefghijklmnopqrst", S("abcdefghij"), true);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test("", S(""), true);
diff --git a/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_pointer.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_pointer.pass.cpp
index 56b3b35b3d94..4042997f462f 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_pointer.pass.cpp
@@ -45,7 +45,7 @@ int main()
     test(S("abcdefghijklmnopqrst"), "abcdefghij", true);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), "", true);
diff --git a/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string.pass.cpp
index c02b202c49e6..cdcfc9d8d14a 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string.pass.cpp
@@ -46,7 +46,7 @@ int main()
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), S(""), true);
diff --git a/test/std/strings/basic.string/string.nonmembers/string_oplt/pointer_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_oplt/pointer_string.pass.cpp
index 86f6a2db119a..e709aa4fbc42 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_oplt/pointer_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_oplt/pointer_string.pass.cpp
@@ -45,7 +45,7 @@ int main()
     test("abcdefghijklmnopqrst", S("abcdefghij"), false);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test("", S(""), false);
diff --git a/test/std/strings/basic.string/string.nonmembers/string_oplt/string_pointer.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_oplt/string_pointer.pass.cpp
index b935da5426fd..8e4f2fab13a4 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_oplt/string_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_oplt/string_pointer.pass.cpp
@@ -45,7 +45,7 @@ int main()
     test(S("abcdefghijklmnopqrst"), "abcdefghij", false);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), "", false);
diff --git a/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string.pass.cpp
index 487e2056f2ca..c14e92a0003c 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string.pass.cpp
@@ -46,7 +46,7 @@ int main()
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), S(""), false);
diff --git a/test/std/strings/basic.string/string.nonmembers/string_oplt=/pointer_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_oplt=/pointer_string.pass.cpp
index 21959405194d..acab3592ec17 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_oplt=/pointer_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_oplt=/pointer_string.pass.cpp
@@ -45,7 +45,7 @@ int main()
     test("abcdefghijklmnopqrst", S("abcdefghij"), false);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test("", S(""), true);
diff --git a/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_pointer.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_pointer.pass.cpp
index bb1bce8d4043..f0f540a499c7 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_pointer.pass.cpp
@@ -45,7 +45,7 @@ int main()
     test(S("abcdefghijklmnopqrst"), "abcdefghij", false);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), "", true);
diff --git a/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string.pass.cpp
index 2b975f160d5d..208f9623929d 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string.pass.cpp
@@ -46,7 +46,7 @@ int main()
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), S(""), true);
diff --git a/test/std/strings/basic.string/string.ops/string.accessors/c_str.pass.cpp b/test/std/strings/basic.string/string.ops/string.accessors/c_str.pass.cpp
index 3bdb800bf736..d6695b0b34bc 100644
--- a/test/std/strings/basic.string/string.ops/string.accessors/c_str.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string.accessors/c_str.pass.cpp
@@ -40,7 +40,7 @@ int main()
     test(S("abcdefghij"));
     test(S("abcdefghijklmnopqrst"));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""));
diff --git a/test/std/strings/basic.string/string.ops/string.accessors/data.pass.cpp b/test/std/strings/basic.string/string.ops/string.accessors/data.pass.cpp
index 917248fa6916..9b66cb004990 100644
--- a/test/std/strings/basic.string/string.ops/string.accessors/data.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string.accessors/data.pass.cpp
@@ -10,15 +10,17 @@
 // <string>
 
 // const charT* data() const;
+//       charT* data();   // C++17
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
-test(const S& s)
+test_const(const S& s)
 {
     typedef typename S::traits_type T;
     const typename S::value_type* str = s.data();
@@ -31,22 +33,46 @@ test(const S& s)
         assert(T::eq(str[0], typename S::value_type()));
 }
 
+template <class S>
+void
+test_nonconst(S& s)
+{
+    typedef typename S::traits_type T;
+    typename S::value_type* str = s.data();
+    if (s.size() > 0)
+    {
+        assert(T::compare(str, &s[0], s.size()) == 0);
+        assert(T::eq(str[s.size()], typename S::value_type()));
+    }
+    else
+        assert(T::eq(str[0], typename S::value_type()));
+}
+
 int main()
 {
     {
     typedef std::string S;
-    test(S(""));
-    test(S("abcde"));
-    test(S("abcdefghij"));
-    test(S("abcdefghijklmnopqrst"));
+    test_const(S(""));
+    test_const(S("abcde"));
+    test_const(S("abcdefghij"));
+    test_const(S("abcdefghijklmnopqrst"));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S(""));
-    test(S("abcde"));
-    test(S("abcdefghij"));
-    test(S("abcdefghijklmnopqrst"));
+    test_const(S(""));
+    test_const(S("abcde"));
+    test_const(S("abcdefghij"));
+    test_const(S("abcdefghijklmnopqrst"));
+    }
+#endif
+#if TEST_STD_VER > 14
+    {
+    typedef std::string S;
+    S s1("");                     test_nonconst(s1);
+    S s2("abcde");                test_nonconst(s2);
+    S s3("abcdefghij");           test_nonconst(s3);
+    S s4("abcdefghijklmnopqrst"); test_nonconst(s4);
     }
 #endif
 }
diff --git a/test/std/strings/basic.string/string.ops/string.accessors/get_allocator.pass.cpp b/test/std/strings/basic.string/string.ops/string.accessors/get_allocator.pass.cpp
index 6ba040d2635d..e50c61fb162a 100644
--- a/test/std/strings/basic.string/string.ops/string.accessors/get_allocator.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string.accessors/get_allocator.pass.cpp
@@ -34,7 +34,7 @@ int main()
     test(S("abcdefghij", A(2)), A(2));
     test(S("abcdefghijklmnopqrst", A(3)), A(3));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef min_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
diff --git a/test/std/strings/basic.string/string.ops/string_compare/pointer.pass.cpp b/test/std/strings/basic.string/string.ops/string_compare/pointer.pass.cpp
index dda7428992a1..150973a7f4e4 100644
--- a/test/std/strings/basic.string/string.ops/string_compare/pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_compare/pointer.pass.cpp
@@ -53,7 +53,7 @@ int main()
     test(S("abcdefghijklmnopqrst"), "abcdefghij", 10);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), "", 0);
diff --git a/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp b/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp
index 2fef19a24df9..094c227030b8 100644
--- a/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp
@@ -362,7 +362,7 @@ int main()
     test1<S>();
     test2<S>();
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
diff --git a/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp
index cc61a2e453c4..22aae785c19a 100644
--- a/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp
@@ -1304,7 +1304,7 @@ int main()
     test10<S>();
     test11<S>();
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
diff --git a/test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp b/test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp
index 66417482fb58..90b4230f64da 100644
--- a/test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp
@@ -362,7 +362,7 @@ int main()
     test1<S>();
     test2<S>();
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
diff --git a/test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp
index f5c067699233..3cbbea7b490b 100644
--- a/test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp
@@ -5885,7 +5885,7 @@ int main()
     test54<S>();
     test55<S>();
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
diff --git a/test/std/strings/basic.string/string.ops/string_compare/string.pass.cpp b/test/std/strings/basic.string/string.ops/string_compare/string.pass.cpp
index 7de95a8cda56..3f6c169d223a 100644
--- a/test/std/strings/basic.string/string.ops/string_compare/string.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_compare/string.pass.cpp
@@ -53,7 +53,7 @@ int main()
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), 10);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), S(""), 0);
diff --git a/test/std/strings/basic.string/string.ops/string_find.first.not.of/char_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.first.not.of/char_size.pass.cpp
index 590173eddf41..945f8805487d 100644
--- a/test/std/strings/basic.string/string.ops/string_find.first.not.of/char_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.first.not.of/char_size.pass.cpp
@@ -67,7 +67,7 @@ int main()
     test(S("gfsmthlkon"), 'q', 0);
     test(S("laenfsbridchgotmkqpj"), 'q', 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 'q', 0, S::npos);
diff --git a/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size.pass.cpp
index 53d3a95292c2..0c239b323508 100644
--- a/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size.pass.cpp
@@ -148,7 +148,7 @@ int main()
     test0<S>();
     test1<S>();
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
diff --git a/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size_size.pass.cpp
index 14ac4b2a153b..0296e2cbee38 100644
--- a/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size_size.pass.cpp
@@ -375,7 +375,7 @@ int main()
     test2<S>();
     test3<S>();
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
diff --git a/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_size.pass.cpp
index 4fb072fa4744..b7df3461792b 100644
--- a/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_size.pass.cpp
@@ -147,7 +147,7 @@ int main()
     test0<S>();
     test1<S>();
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
diff --git a/test/std/strings/basic.string/string.ops/string_find.first.of/char_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.first.of/char_size.pass.cpp
index 32d0e86f3d84..494a1181f2ae 100644
--- a/test/std/strings/basic.string/string.ops/string_find.first.of/char_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.first.of/char_size.pass.cpp
@@ -65,7 +65,7 @@ int main()
     test(S("gfsmthlkon"), 'e', S::npos);
     test(S("laenfsbridchgotmkqpj"), 'e', 2);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 'e', 0, S::npos);
diff --git a/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size.pass.cpp
index 6dd176df0165..b2a05b29f134 100644
--- a/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size.pass.cpp
@@ -148,7 +148,7 @@ int main()
     test0<S>();
     test1<S>();
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
diff --git a/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size_size.pass.cpp
index 9e98a6ad20f7..8b7f7b4a5884 100644
--- a/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size_size.pass.cpp
@@ -375,7 +375,7 @@ int main()
     test2<S>();
     test3<S>();
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
diff --git a/test/std/strings/basic.string/string.ops/string_find.first.of/string_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.first.of/string_size.pass.cpp
index e409edc25f48..765d1603af8c 100644
--- a/test/std/strings/basic.string/string.ops/string_find.first.of/string_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.first.of/string_size.pass.cpp
@@ -147,7 +147,7 @@ int main()
     test0<S>();
     test1<S>();
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
diff --git a/test/std/strings/basic.string/string.ops/string_find.last.not.of/char_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.last.not.of/char_size.pass.cpp
index b130f9287ba3..3212389bb3a8 100644
--- a/test/std/strings/basic.string/string.ops/string_find.last.not.of/char_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.last.not.of/char_size.pass.cpp
@@ -65,7 +65,7 @@ int main()
     test(S("gfsmthlkon"), 'i', 9);
     test(S("laenfsbridchgotmkqpj"), 'i', 19);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 'i', 0, S::npos);
diff --git a/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size.pass.cpp
index 3e6bd9d093ea..7dc75184ff99 100644
--- a/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size.pass.cpp
@@ -148,7 +148,7 @@ int main()
     test0<S>();
     test1<S>();
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
diff --git a/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size_size.pass.cpp
index 4db7762b2755..2024266df4a6 100644
--- a/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size_size.pass.cpp
@@ -375,7 +375,7 @@ int main()
     test2<S>();
     test3<S>();
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
diff --git a/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_size.pass.cpp
index ba93adbe445e..f3377596ab3d 100644
--- a/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_size.pass.cpp
@@ -147,7 +147,7 @@ int main()
     test0<S>();
     test1<S>();
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
diff --git a/test/std/strings/basic.string/string.ops/string_find.last.of/char_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.last.of/char_size.pass.cpp
index 12765b71f28f..e0bbd82f6679 100644
--- a/test/std/strings/basic.string/string.ops/string_find.last.of/char_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.last.of/char_size.pass.cpp
@@ -65,7 +65,7 @@ int main()
     test(S("gfsmthlkon"), 'm', 3);
     test(S("laenfsbridchgotmkqpj"), 'm', 15);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 'm', 0, S::npos);
diff --git a/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size.pass.cpp
index f1b447c43f4b..c3d6044c4201 100644
--- a/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size.pass.cpp
@@ -148,7 +148,7 @@ int main()
     test0<S>();
     test1<S>();
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
diff --git a/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size_size.pass.cpp
index 7f96e6351aa6..42a076aa4c56 100644
--- a/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size_size.pass.cpp
@@ -375,7 +375,7 @@ int main()
     test2<S>();
     test3<S>();
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
diff --git a/test/std/strings/basic.string/string.ops/string_find.last.of/string_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.last.of/string_size.pass.cpp
index 351c6727de2d..5cb2df7c6c7f 100644
--- a/test/std/strings/basic.string/string.ops/string_find.last.of/string_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.last.of/string_size.pass.cpp
@@ -147,7 +147,7 @@ int main()
     test0<S>();
     test1<S>();
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
diff --git a/test/std/strings/basic.string/string.ops/string_find/char_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find/char_size.pass.cpp
index 24e58fc5f1ad..a084348b3e63 100644
--- a/test/std/strings/basic.string/string.ops/string_find/char_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find/char_size.pass.cpp
@@ -65,7 +65,7 @@ int main()
     test(S("abcdeabcde"), 'c', 2);
     test(S("abcdeabcdeabcdeabcde"), 'c', 2);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 'c', 0, S::npos);
diff --git a/test/std/strings/basic.string/string.ops/string_find/pointer_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find/pointer_size.pass.cpp
index e00d7fd8a3dc..0257e125953f 100644
--- a/test/std/strings/basic.string/string.ops/string_find/pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find/pointer_size.pass.cpp
@@ -154,7 +154,7 @@ int main()
     test0<S>();
     test1<S>();
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
diff --git a/test/std/strings/basic.string/string.ops/string_find/pointer_size_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find/pointer_size_size.pass.cpp
index 3006c466eed3..9a380f72982d 100644
--- a/test/std/strings/basic.string/string.ops/string_find/pointer_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find/pointer_size_size.pass.cpp
@@ -375,7 +375,7 @@ int main()
     test2<S>();
     test3<S>();
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
diff --git a/test/std/strings/basic.string/string.ops/string_find/string_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find/string_size.pass.cpp
index a89df4e3ffa1..e519a7943ba9 100644
--- a/test/std/strings/basic.string/string.ops/string_find/string_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find/string_size.pass.cpp
@@ -147,7 +147,7 @@ int main()
     test0<S>();
     test1<S>();
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
diff --git a/test/std/strings/basic.string/string.ops/string_rfind/char_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_rfind/char_size.pass.cpp
index cbc0c9b35367..c53d77f348b8 100644
--- a/test/std/strings/basic.string/string.ops/string_rfind/char_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_rfind/char_size.pass.cpp
@@ -65,7 +65,7 @@ int main()
     test(S("abcdeabcde"), 'b', 6);
     test(S("abcdeabcdeabcdeabcde"), 'b', 16);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 'b', 0, S::npos);
diff --git a/test/std/strings/basic.string/string.ops/string_rfind/pointer_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_rfind/pointer_size.pass.cpp
index 450aebedd59c..ebcb0ea3859a 100644
--- a/test/std/strings/basic.string/string.ops/string_rfind/pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_rfind/pointer_size.pass.cpp
@@ -155,7 +155,7 @@ int main()
     test0<S>();
     test1<S>();
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
diff --git a/test/std/strings/basic.string/string.ops/string_rfind/pointer_size_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_rfind/pointer_size_size.pass.cpp
index 47baf40b265b..e8d0c6b73871 100644
--- a/test/std/strings/basic.string/string.ops/string_rfind/pointer_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_rfind/pointer_size_size.pass.cpp
@@ -375,7 +375,7 @@ int main()
     test2<S>();
     test3<S>();
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
diff --git a/test/std/strings/basic.string/string.ops/string_rfind/string_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_rfind/string_size.pass.cpp
index 05e6e5174232..ef571c284b81 100644
--- a/test/std/strings/basic.string/string.ops/string_rfind/string_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_rfind/string_size.pass.cpp
@@ -147,7 +147,7 @@ int main()
     test0<S>();
     test1<S>();
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
diff --git a/test/std/strings/basic.string/string.ops/string_substr/substr.pass.cpp b/test/std/strings/basic.string/string.ops/string_substr/substr.pass.cpp
index dc01f4f47747..145e8dde58bf 100644
--- a/test/std/strings/basic.string/string.ops/string_substr/substr.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_substr/substr.pass.cpp
@@ -17,6 +17,7 @@
 #include <algorithm>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
@@ -26,7 +27,7 @@ test(const S& s, typename S::size_type pos, typename S::size_type n)
     try
     {
         S str = s.substr(pos, n);
-        assert(str.__invariants());
+        LIBCPP_ASSERT(str.__invariants());
         assert(pos <= s.size());
         typename S::size_type rlen = std::min(n, s.size() - pos);
         assert(str.size() == rlen);
@@ -101,7 +102,7 @@ int main()
     test(S("lsaijeqhtrbgcdmpfkno"), 20, 0);
     test(S("dplqartnfgejichmoskb"), 21, 0);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 0, 0);
diff --git a/test/std/strings/basic.string/string.require/contiguous.pass.cpp b/test/std/strings/basic.string/string.require/contiguous.pass.cpp
index ca31ace0ef0b..49773fe491a2 100644
--- a/test/std/strings/basic.string/string.require/contiguous.pass.cpp
+++ b/test/std/strings/basic.string/string.require/contiguous.pass.cpp
@@ -41,7 +41,7 @@ int main()
     test_contiguous(S("1", A(5)));
     test_contiguous(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)));
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     {
     typedef min_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
diff --git a/test/std/strings/basic.string/types.pass.cpp b/test/std/strings/basic.string/types.pass.cpp
index dcb3bbc35ebf..a6832a158eca 100644
--- a/test/std/strings/basic.string/types.pass.cpp
+++ b/test/std/strings/basic.string/types.pass.cpp
@@ -79,7 +79,7 @@ int main()
                                 std::char_traits<char> >::value), "");
     static_assert((std::is_same<std::basic_string<char>::allocator_type,
                                 std::allocator<char> >::value), "");
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test<std::char_traits<char>, min_allocator<char> >();
 #endif
 }
diff --git a/test/std/strings/c.strings/cstring.pass.cpp b/test/std/strings/c.strings/cstring.pass.cpp
index 20f4050cfbdb..63f86d350610 100644
--- a/test/std/strings/c.strings/cstring.pass.cpp
+++ b/test/std/strings/c.strings/cstring.pass.cpp
@@ -34,17 +34,12 @@ int main()
     static_assert((std::is_same<decltype(std::strncmp(cpc, cpc, s)), int>::value), "");
     static_assert((std::is_same<decltype(std::strcoll(cpc, cpc)), int>::value), "");
     static_assert((std::is_same<decltype(std::strxfrm(cp, cpc, s)), std::size_t>::value), "");
-//    static_assert((std::is_same<decltype(std::memchr(vpc, 0, s)), const void*>::value), "");
     static_assert((std::is_same<decltype(std::memchr(vp, 0, s)), void*>::value), "");
-//    static_assert((std::is_same<decltype(std::strchr(cpc, 0)), const char*>::value), "");
     static_assert((std::is_same<decltype(std::strchr(cp, 0)), char*>::value), "");
     static_assert((std::is_same<decltype(std::strcspn(cpc, cpc)), std::size_t>::value), "");
-//    static_assert((std::is_same<decltype(std::strpbrk(cpc, cpc)), const char*>::value), "");
     static_assert((std::is_same<decltype(std::strpbrk(cp, cpc)), char*>::value), "");
-//    static_assert((std::is_same<decltype(std::strrchr(cpc, 0)), const char*>::value), "");
     static_assert((std::is_same<decltype(std::strrchr(cp, 0)), char*>::value), "");
     static_assert((std::is_same<decltype(std::strspn(cpc, cpc)), std::size_t>::value), "");
-//    static_assert((std::is_same<decltype(std::strstr(cpc, cpc)), const char*>::value), "");
     static_assert((std::is_same<decltype(std::strstr(cp, cpc)), char*>::value), "");
 #ifndef _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS
     static_assert((std::is_same<decltype(std::strtok(cp, cpc)), char*>::value), "");
@@ -52,4 +47,15 @@ int main()
     static_assert((std::is_same<decltype(std::memset(vp, 0, s)), void*>::value), "");
     static_assert((std::is_same<decltype(std::strerror(0)), char*>::value), "");
     static_assert((std::is_same<decltype(std::strlen(cpc)), std::size_t>::value), "");
+
+    // These tests fail on systems whose C library doesn't provide a correct overload
+    // set for strchr, strpbrk, strrchr, strstr, and memchr, unless the compiler is
+    // a suitably recent version of Clang.
+#if !defined(__APPLE__) || defined(_LIBCPP_PREFERRED_OVERLOAD)
+    static_assert((std::is_same<decltype(std::memchr(vpc, 0, s)), const void*>::value), "");
+    static_assert((std::is_same<decltype(std::strchr(cpc, 0)), const char*>::value), "");
+    static_assert((std::is_same<decltype(std::strpbrk(cpc, cpc)), const char*>::value), "");
+    static_assert((std::is_same<decltype(std::strrchr(cpc, 0)), const char*>::value), "");
+    static_assert((std::is_same<decltype(std::strstr(cpc, cpc)), const char*>::value), "");
+#endif
 }
diff --git a/test/std/strings/c.strings/cwchar.pass.cpp b/test/std/strings/c.strings/cwchar.pass.cpp
index 93d2bb1efa50..2b7c3c465f6d 100644
--- a/test/std/strings/c.strings/cwchar.pass.cpp
+++ b/test/std/strings/c.strings/cwchar.pass.cpp
@@ -10,6 +10,7 @@
 // <cwchar>
 
 #include <cwchar>
+#include <cstdarg>
 #include <type_traits>
 
 #ifndef NULL
@@ -35,13 +36,20 @@ int main()
     std::tm *tm = 0;
     std::wint_t w = 0;
     ::FILE* fp = 0;
-#ifdef __APPLE__
-    __darwin_va_list va;
-#else
-    __builtin_va_list va;
-#endif
+    std::va_list va;
+
     char* ns = 0;
     wchar_t* ws = 0;
+
+    ((void)mb); // Prevent unused warning
+    ((void)s); // Prevent unused warning
+    ((void)tm); // Prevent unused warning
+    ((void)w); // Prevent unused warning
+    ((void)fp); // Prevent unused warning
+    ((void)va); // Prevent unused warning
+    ((void)ns); // Prevent unused warning
+    ((void)ws); // Prevent unused warning
+
     static_assert((std::is_same<decltype(std::fwprintf(fp, L"")), int>::value), "");
     static_assert((std::is_same<decltype(std::fwscanf(fp, L"")), int>::value), "");
     static_assert((std::is_same<decltype(std::swprintf(ws, s, L"")), int>::value), "");
@@ -73,19 +81,14 @@ int main()
     static_assert((std::is_same<decltype(std::wcscoll(L"", L"")), int>::value), "");
     static_assert((std::is_same<decltype(std::wcsncmp(L"", L"", s)), int>::value), "");
     static_assert((std::is_same<decltype(std::wcsxfrm(ws, L"", s)), std::size_t>::value), "");
-    static_assert((std::is_same<decltype(std::wcschr((const wchar_t*)0, L' ')), const wchar_t*>::value), "");
     static_assert((std::is_same<decltype(std::wcschr((wchar_t*)0, L' ')), wchar_t*>::value), "");
     static_assert((std::is_same<decltype(std::wcscspn(L"", L"")), std::size_t>::value), "");
     static_assert((std::is_same<decltype(std::wcslen(L"")), std::size_t>::value), "");
-    static_assert((std::is_same<decltype(std::wcspbrk((const wchar_t*)0, L"")), const wchar_t*>::value), "");
     static_assert((std::is_same<decltype(std::wcspbrk((wchar_t*)0, L"")), wchar_t*>::value), "");
-    static_assert((std::is_same<decltype(std::wcsrchr((const wchar_t*)0, L' ')), const wchar_t*>::value), "");
     static_assert((std::is_same<decltype(std::wcsrchr((wchar_t*)0, L' ')), wchar_t*>::value), "");
     static_assert((std::is_same<decltype(std::wcsspn(L"", L"")), std::size_t>::value), "");
-    static_assert((std::is_same<decltype(std::wcsstr((const wchar_t*)0, L"")), const wchar_t*>::value), "");
     static_assert((std::is_same<decltype(std::wcsstr((wchar_t*)0, L"")), wchar_t*>::value), "");
     static_assert((std::is_same<decltype(std::wcstok(ws, L"", (wchar_t**)0)), wchar_t*>::value), "");
-    static_assert((std::is_same<decltype(std::wmemchr((const wchar_t*)0, L' ', s)), const wchar_t*>::value), "");
     static_assert((std::is_same<decltype(std::wmemchr((wchar_t*)0, L' ', s)), wchar_t*>::value), "");
     static_assert((std::is_same<decltype(std::wmemcmp(L"", L"", s)), int>::value), "");
     static_assert((std::is_same<decltype(std::wmemcpy(ws, L"", s)), wchar_t*>::value), "");
@@ -101,6 +104,17 @@ int main()
     static_assert((std::is_same<decltype(std::mbsrtowcs(ws, (const char**)0, s, &mb)), std::size_t>::value), "");
     static_assert((std::is_same<decltype(std::wcsrtombs(ns, (const wchar_t**)0, s, &mb)), std::size_t>::value), "");
 
+    // These tests fail on systems whose C library doesn't provide a correct overload
+    // set for wcschr, wcspbrk, wcsrchr, wcsstr, and wmemchr, unless the compiler is
+    // a suitably recent version of Clang.
+#if !defined(__APPLE__) || defined(_LIBCPP_PREFERRED_OVERLOAD)
+    static_assert((std::is_same<decltype(std::wcschr((const wchar_t*)0, L' ')), const wchar_t*>::value), "");
+    static_assert((std::is_same<decltype(std::wcspbrk((const wchar_t*)0, L"")), const wchar_t*>::value), "");
+    static_assert((std::is_same<decltype(std::wcsrchr((const wchar_t*)0, L' ')), const wchar_t*>::value), "");
+    static_assert((std::is_same<decltype(std::wcsstr((const wchar_t*)0, L"")), const wchar_t*>::value), "");
+    static_assert((std::is_same<decltype(std::wmemchr((const wchar_t*)0, L' ', s)), const wchar_t*>::value), "");
+#endif
+
 #ifndef _LIBCPP_HAS_NO_STDIN
     static_assert((std::is_same<decltype(std::getwchar()), std::wint_t>::value), "");
     static_assert((std::is_same<decltype(std::vwscanf(L"", va)), int>::value), "");
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/lt.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/lt.pass.cpp
index 3ff9c0f1ff92..9b552347fe9e 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/lt.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/lt.pass.cpp
@@ -1,6 +1,6 @@
 //===----------------------------------------------------------------------===//
 //
-//                     The LLVM Compiler Infrastructure
+//					   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.
@@ -18,11 +18,16 @@
 
 int main()
 {
-    char c = '\0';
-    assert(!std::char_traits<char>::lt('a', 'a'));
-    assert( std::char_traits<char>::lt('A', 'a'));
-    assert(!std::char_traits<char>::lt('A' + 127, 'a'));
-    assert(!std::char_traits<char>::lt('A' - 127, 'a'));
-    assert( std::char_traits<char>::lt('A', 'a' + 127));
-    assert( std::char_traits<char>::lt('A', 'a' - 127));
+	assert( std::char_traits<char>::lt('\0', 'A'));
+	assert(!std::char_traits<char>::lt('A', '\0'));
+
+	assert(!std::char_traits<char>::lt('a', 'a'));
+	assert( std::char_traits<char>::lt('A', 'a'));
+	assert(!std::char_traits<char>::lt('a', 'A'));
+
+	assert( std::char_traits<char>::lt('a', 'z'));
+	assert( std::char_traits<char>::lt('A', 'Z'));
+
+	assert( std::char_traits<char>::lt(' ', 'A'));
+	assert( std::char_traits<char>::lt('A', '~'));
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/assign2.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/assign2.pass.cpp
index af87052ff219..7f223af57414 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/assign2.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/assign2.pass.cpp
@@ -16,10 +16,12 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     char16_t c = u'\0';
     std::char_traits<char16_t>::assign(c, u'a');
     assert(c == u'a');
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/compare.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/compare.pass.cpp
index b5039072dbfd..7356097a6677 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/compare.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/compare.pass.cpp
@@ -16,10 +16,12 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     assert(std::char_traits<char16_t>::compare(u"", u"", 0) == 0);
     assert(std::char_traits<char16_t>::compare(NULL, NULL, 0) == 0);
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq.pass.cpp
index 8216934658ce..1ae4cb8fe8d9 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq.pass.cpp
@@ -16,10 +16,12 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     char16_t c = u'\0';
     assert(std::char_traits<char16_t>::eq(u'a', u'a'));
     assert(!std::char_traits<char16_t>::eq(u'a', u'A'));
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq_int_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq_int_type.pass.cpp
index a20aa7d47189..42546f450fc7 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq_int_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq_int_type.pass.cpp
@@ -16,10 +16,12 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     assert( std::char_traits<char16_t>::eq_int_type(u'a', u'a'));
     assert(!std::char_traits<char16_t>::eq_int_type(u'a', u'A'));
     assert(!std::char_traits<char16_t>::eq_int_type(std::char_traits<char16_t>::eof(), u'A'));
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/length.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/length.pass.cpp
index 9f6acca83e36..ff5a2a934a9f 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/length.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/length.pass.cpp
@@ -16,10 +16,12 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     assert(std::char_traits<char16_t>::length(u"") == 0);
     assert(std::char_traits<char16_t>::length(u"a") == 1);
     assert(std::char_traits<char16_t>::length(u"aa") == 2);
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/lt.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/lt.pass.cpp
index 135ecc05e199..b27ee06f4a59 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/lt.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/lt.pass.cpp
@@ -16,10 +16,12 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     char16_t c = u'\0';
     assert(!std::char_traits<char16_t>::lt(u'a', u'a'));
     assert( std::char_traits<char16_t>::lt(u'A', u'a'));
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/not_eof.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/not_eof.pass.cpp
index 3c213e6e0a37..af9378073bec 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/not_eof.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/not_eof.pass.cpp
@@ -16,10 +16,12 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     assert(std::char_traits<char16_t>::not_eof(u'a') == u'a');
     assert(std::char_traits<char16_t>::not_eof(u'A') == u'A');
 #endif
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_char_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_char_type.pass.cpp
index ab47403dbe01..2a679d0cf420 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_char_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_char_type.pass.cpp
@@ -16,10 +16,12 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     assert(std::char_traits<char16_t>::to_char_type(u'a') == u'a');
     assert(std::char_traits<char16_t>::to_char_type(u'A') == u'A');
 #endif
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_int_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_int_type.pass.cpp
index 11eb8f525466..93861461baaf 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_int_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_int_type.pass.cpp
@@ -16,10 +16,12 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     assert(std::char_traits<char16_t>::to_int_type(u'a') == u'a');
     assert(std::char_traits<char16_t>::to_int_type(u'A') == u'A');
 #endif
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/assign2.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/assign2.pass.cpp
index 35dcd9602d3c..6cd55ea58bff 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/assign2.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/assign2.pass.cpp
@@ -16,10 +16,12 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     char32_t c = U'\0';
     std::char_traits<char32_t>::assign(c, U'a');
     assert(c == U'a');
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/compare.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/compare.pass.cpp
index 25f2099896a6..2671b5624100 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/compare.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/compare.pass.cpp
@@ -16,10 +16,12 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     assert(std::char_traits<char32_t>::compare(U"", U"", 0) == 0);
     assert(std::char_traits<char32_t>::compare(NULL, NULL, 0) == 0);
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq.pass.cpp
index ffeff0cf45a4..0284d9f7933b 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq.pass.cpp
@@ -16,10 +16,12 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     char32_t c = U'\0';
     assert(std::char_traits<char32_t>::eq(U'a', U'a'));
     assert(!std::char_traits<char32_t>::eq(U'a', U'A'));
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq_int_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq_int_type.pass.cpp
index eb5c69661014..d39798c74bb6 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq_int_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq_int_type.pass.cpp
@@ -16,10 +16,12 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     assert( std::char_traits<char32_t>::eq_int_type(U'a', U'a'));
     assert(!std::char_traits<char32_t>::eq_int_type(U'a', U'A'));
     assert(!std::char_traits<char32_t>::eq_int_type(std::char_traits<char32_t>::eof(), U'A'));
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/length.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/length.pass.cpp
index d80ce051d1fa..e0bee5dc5080 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/length.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/length.pass.cpp
@@ -16,10 +16,12 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     assert(std::char_traits<char32_t>::length(U"") == 0);
     assert(std::char_traits<char32_t>::length(U"a") == 1);
     assert(std::char_traits<char32_t>::length(U"aa") == 2);
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/lt.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/lt.pass.cpp
index f667507f0457..9816df738709 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/lt.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/lt.pass.cpp
@@ -16,10 +16,12 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     char32_t c = U'\0';
     assert(!std::char_traits<char32_t>::lt(U'a', U'a'));
     assert( std::char_traits<char32_t>::lt(U'A', U'a'));
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/not_eof.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/not_eof.pass.cpp
index d794417bfd7a..b83fd0fe07ff 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/not_eof.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/not_eof.pass.cpp
@@ -16,10 +16,12 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     assert(std::char_traits<char32_t>::not_eof(U'a') == U'a');
     assert(std::char_traits<char32_t>::not_eof(U'A') == U'A');
 #endif
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_char_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_char_type.pass.cpp
index 1f67242b2aec..c9820424fb66 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_char_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_char_type.pass.cpp
@@ -16,10 +16,12 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     assert(std::char_traits<char32_t>::to_char_type(U'a') == U'a');
     assert(std::char_traits<char32_t>::to_char_type(U'A') == U'A');
 #endif
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_int_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_int_type.pass.cpp
index a378186bdd6f..801c4cf7cddf 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_int_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_int_type.pass.cpp
@@ -16,10 +16,12 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     assert(std::char_traits<char32_t>::to_int_type(U'a') == U'a');
     assert(std::char_traits<char32_t>::to_int_type(U'A') == U'A');
 #endif
diff --git a/test/std/thread/futures/futures.async/async.pass.cpp b/test/std/thread/futures/futures.async/async.pass.cpp
index 2c1313b7a2f0..5cb824d48224 100644
--- a/test/std/thread/futures/futures.async/async.pass.cpp
+++ b/test/std/thread/futures/futures.async/async.pass.cpp
@@ -21,15 +21,22 @@
 //     future<typename result_of<F(Args...)>::type>
 //     async(launch policy, F&& f, Args&&... args);
 
+
 #include <future>
+#include <atomic>
 #include <memory>
 #include <cassert>
 
+#include "test_macros.h"
+
 typedef std::chrono::high_resolution_clock Clock;
 typedef std::chrono::milliseconds ms;
 
+std::atomic_bool invoked = ATOMIC_VAR_INIT(false);
+
 int f0()
 {
+    invoked = true;
     std::this_thread::sleep_for(ms(200));
     return 3;
 }
@@ -38,163 +45,109 @@ int i = 0;
 
 int& f1()
 {
+    invoked = true;
     std::this_thread::sleep_for(ms(200));
     return i;
 }
 
 void f2()
 {
+    invoked = true;
     std::this_thread::sleep_for(ms(200));
 }
 
-std::unique_ptr<int> f3(int i)
+std::unique_ptr<int> f3(int j)
 {
+    invoked = true;
     std::this_thread::sleep_for(ms(200));
-    return std::unique_ptr<int>(new int(i));
+    return std::unique_ptr<int>(new int(j));
 }
 
 std::unique_ptr<int> f4(std::unique_ptr<int>&& p)
 {
+    invoked = true;
     std::this_thread::sleep_for(ms(200));
     return std::move(p);
 }
 
-void f5(int i)
+void f5(int j)
 {
     std::this_thread::sleep_for(ms(200));
-    throw i;
+    throw j;
 }
 
-int main()
-{
-    {
-        std::future<int> f = std::async(f0);
-        std::this_thread::sleep_for(ms(300));
-        Clock::time_point t0 = Clock::now();
-        assert(f.get() == 3);
-        Clock::time_point t1 = Clock::now();
-        assert(t1-t0 < ms(100));
-    }
-    {
-        std::future<int> f = std::async(std::launch::async, f0);
-        std::this_thread::sleep_for(ms(300));
-        Clock::time_point t0 = Clock::now();
-        assert(f.get() == 3);
-        Clock::time_point t1 = Clock::now();
-        assert(t1-t0 < ms(100));
-    }
-    {
-        std::future<int> f = std::async(std::launch::any, f0);
-        std::this_thread::sleep_for(ms(300));
-        Clock::time_point t0 = Clock::now();
-        assert(f.get() == 3);
-        Clock::time_point t1 = Clock::now();
-        assert(t1-t0 < ms(100));
-    }
-    {
-        std::future<int> f = std::async(std::launch::deferred, f0);
-        std::this_thread::sleep_for(ms(300));
-        Clock::time_point t0 = Clock::now();
-        assert(f.get() == 3);
-        Clock::time_point t1 = Clock::now();
-        assert(t1-t0 > ms(100));
-    }
+template <class Ret, class CheckLamdba, class ...Args>
+void test(CheckLamdba&& getAndCheckFn, bool IsDeferred, Args&&... args) {
+    // Reset global state.
+    invoked = false;
 
-    {
-        std::future<int&> f = std::async(f1);
-        std::this_thread::sleep_for(ms(300));
-        Clock::time_point t0 = Clock::now();
-        assert(&f.get() == &i);
-        Clock::time_point t1 = Clock::now();
-        assert(t1-t0 < ms(100));
-    }
-    {
-        std::future<int&> f = std::async(std::launch::async, f1);
-        std::this_thread::sleep_for(ms(300));
-        Clock::time_point t0 = Clock::now();
-        assert(&f.get() == &i);
-        Clock::time_point t1 = Clock::now();
-        assert(t1-t0 < ms(100));
-    }
-    {
-        std::future<int&> f = std::async(std::launch::any, f1);
-        std::this_thread::sleep_for(ms(300));
-        Clock::time_point t0 = Clock::now();
-        assert(&f.get() == &i);
-        Clock::time_point t1 = Clock::now();
-        assert(t1-t0 < ms(100));
-    }
-    {
-        std::future<int&> f = std::async(std::launch::deferred, f1);
-        std::this_thread::sleep_for(ms(300));
-        Clock::time_point t0 = Clock::now();
-        assert(&f.get() == &i);
-        Clock::time_point t1 = Clock::now();
-        assert(t1-t0 > ms(100));
-    }
+    // Create the future and wait
+    std::future<Ret> f = std::async(std::forward<Args>(args)...);
+    std::this_thread::sleep_for(ms(300));
 
-    {
-        std::future<void> f = std::async(f2);
-        std::this_thread::sleep_for(ms(300));
-        Clock::time_point t0 = Clock::now();
-        f.get();
-        Clock::time_point t1 = Clock::now();
-        assert(t1-t0 < ms(100));
-    }
-    {
-        std::future<void> f = std::async(std::launch::async, f2);
-        std::this_thread::sleep_for(ms(300));
-        Clock::time_point t0 = Clock::now();
-        f.get();
-        Clock::time_point t1 = Clock::now();
+    // Check that deferred async's have not invoked the function.
+    assert(invoked == !IsDeferred);
+
+    // Time the call to f.get() and check that the returned value matches
+    // what is expected.
+    Clock::time_point t0 = Clock::now();
+    assert(getAndCheckFn(f));
+    Clock::time_point t1 = Clock::now();
+
+    // If the async is deferred it should take more than 100ms, otherwise
+    // it should take less than 100ms.
+    if (IsDeferred) {
+        assert(t1-t0 > ms(100));
+    } else {
         assert(t1-t0 < ms(100));
     }
+}
+
+int main()
+{
+    // The default launch policy is implementation defined. libc++ defines
+    // it to be std::launch::async.
+    bool DefaultPolicyIsDeferred = false;
+    bool DPID = DefaultPolicyIsDeferred;
+
+    std::launch AnyPolicy = std::launch::async | std::launch::deferred;
+    LIBCPP_ASSERT(AnyPolicy == std::launch::any);
+
     {
-        std::future<void> f = std::async(std::launch::any, f2);
-        std::this_thread::sleep_for(ms(300));
-        Clock::time_point t0 = Clock::now();
-        f.get();
-        Clock::time_point t1 = Clock::now();
-        assert(t1-t0 < ms(100));
+        auto checkInt = [](std::future<int>& f) { return f.get() == 3; };
+        test<int>(checkInt, DPID,  f0);
+        test<int>(checkInt, false, std::launch::async, f0);
+        test<int>(checkInt, true,  std::launch::deferred, f0);
+        test<int>(checkInt, DPID,  AnyPolicy, f0);
     }
     {
-        std::future<void> f = std::async(std::launch::deferred, f2);
-        std::this_thread::sleep_for(ms(300));
-        Clock::time_point t0 = Clock::now();
-        f.get();
-        Clock::time_point t1 = Clock::now();
-        assert(t1-t0 > ms(100));
+        auto checkIntRef = [&](std::future<int&>& f) { return &f.get() == &i; };
+        test<int&>(checkIntRef, DPID,  f1);
+        test<int&>(checkIntRef, false, std::launch::async, f1);
+        test<int&>(checkIntRef, true,  std::launch::deferred, f1);
+        test<int&>(checkIntRef, DPID,  AnyPolicy, f1);
     }
-
     {
-        std::future<std::unique_ptr<int>> f = std::async(f3, 3);
-        std::this_thread::sleep_for(ms(300));
-        Clock::time_point t0 = Clock::now();
-        assert(*f.get() == 3);
-        Clock::time_point t1 = Clock::now();
-        assert(t1-t0 < ms(100));
+        auto checkVoid = [](std::future<void>& f) { f.get(); return true; };
+        test<void>(checkVoid, DPID,  f2);
+        test<void>(checkVoid, false, std::launch::async, f2);
+        test<void>(checkVoid, true,  std::launch::deferred, f2);
+        test<void>(checkVoid, DPID,  AnyPolicy, f2);
     }
-
     {
-        std::future<std::unique_ptr<int>> f =
-                               std::async(f4, std::unique_ptr<int>(new int(3)));
-        std::this_thread::sleep_for(ms(300));
-        Clock::time_point t0 = Clock::now();
-        assert(*f.get() == 3);
-        Clock::time_point t1 = Clock::now();
-        assert(t1-t0 < ms(100));
+        using Ret = std::unique_ptr<int>;
+        auto checkUPtr = [](std::future<Ret>& f) { return *f.get() == 3; };
+        test<Ret>(checkUPtr, DPID, f3, 3);
+        test<Ret>(checkUPtr, DPID, f4, std::unique_ptr<int>(new int(3)));
     }
-
     {
         std::future<void> f = std::async(f5, 3);
         std::this_thread::sleep_for(ms(300));
-        try { f.get(); assert (false); } catch ( int ex ) {}
+        try { f.get(); assert (false); } catch ( int ) {}
     }
-
     {
         std::future<void> f = std::async(std::launch::deferred, f5, 3);
         std::this_thread::sleep_for(ms(300));
-        try { f.get(); assert (false); } catch ( int ex ) {}
+        try { f.get(); assert (false); } catch ( int ) {}
     }
-
 }
diff --git a/test/std/thread/futures/futures.overview/future_errc.pass.cpp b/test/std/thread/futures/futures.overview/future_errc.pass.cpp
index 1e6fcb76a0e7..06397487a734 100644
--- a/test/std/thread/futures/futures.overview/future_errc.pass.cpp
+++ b/test/std/thread/futures/futures.overview/future_errc.pass.cpp
@@ -9,22 +9,32 @@
 //
 // UNSUPPORTED: libcpp-has-no-threads
 
+// UNSUPPORTED: c++98, c++03
+// Libc++'s enum class emulation does not allow static_cast<Enum>(0) to work.
+
 // <future>
 
 // enum class future_errc
 // {
-//     future_already_retrieved = 1,
-//     promise_already_satisfied,
-//     no_state
-//     broken_promise,
+//     broken_promise = implementation-defined,
+//     future_already_retrieved = implementation-defined,
+//     promise_already_satisfied = implementation-defined,
+//     no_state = implementation-defined
 // };
 
 #include <future>
 
 int main()
 {
-    static_assert(static_cast<int>(std::future_errc::future_already_retrieved) == 1, "");
-    static_assert(static_cast<int>(std::future_errc::promise_already_satisfied) == 2, "");
-    static_assert(static_cast<int>(std::future_errc::no_state) == 3, "");
-    static_assert(static_cast<int>(std::future_errc::broken_promise) == 4, "");
+    static_assert(std::future_errc::broken_promise != std::future_errc::future_already_retrieved, "");
+    static_assert(std::future_errc::broken_promise != std::future_errc::promise_already_satisfied, "");
+    static_assert(std::future_errc::broken_promise != std::future_errc::no_state, "");
+    static_assert(std::future_errc::future_already_retrieved != std::future_errc::promise_already_satisfied, "");
+    static_assert(std::future_errc::future_already_retrieved != std::future_errc::no_state, "");
+    static_assert(std::future_errc::promise_already_satisfied != std::future_errc::no_state, "");
+
+    static_assert(std::future_errc::broken_promise != static_cast<std::future_errc>(0), "");
+    static_assert(std::future_errc::future_already_retrieved != static_cast<std::future_errc>(0), "");
+    static_assert(std::future_errc::promise_already_satisfied != static_cast<std::future_errc>(0), "");
+    static_assert(std::future_errc::no_state != static_cast<std::future_errc>(0), "");
 }
diff --git a/test/std/thread/futures/futures.overview/launch.pass.cpp b/test/std/thread/futures/futures.overview/launch.pass.cpp
index da54f7ee6732..a26b01f67b3e 100644
--- a/test/std/thread/futures/futures.overview/launch.pass.cpp
+++ b/test/std/thread/futures/futures.overview/launch.pass.cpp
@@ -15,28 +15,30 @@
 // {
 //     async = 1,
 //     deferred = 2,
-//     any = async | deferred
+//     any = async | deferred /* EXTENSION */
 // };
 
 #include <future>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
 #ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
-    static_assert(static_cast<int>(std::launch::any) ==
+   LIBCPP_STATIC_ASSERT(static_cast<int>(std::launch::any) ==
                  (static_cast<int>(std::launch::async) | static_cast<int>(std::launch::deferred)), "");
 #else
-    static_assert(std::launch::any == (std::launch::async | std::launch::deferred), "");
+    LIBCPP_STATIC_ASSERT(std::launch::any == (std::launch::async | std::launch::deferred), "");
     static_assert(std::launch(0) == (std::launch::async & std::launch::deferred), "");
-    static_assert(std::launch::any == (std::launch::async ^ std::launch::deferred), "");
-    static_assert(std::launch::deferred == ~std::launch::async, "");
+    LIBCPP_STATIC_ASSERT(std::launch::any == (std::launch::async ^ std::launch::deferred), "");
+    LIBCPP_STATIC_ASSERT(std::launch::deferred == ~std::launch::async, "");
     std::launch x = std::launch::async;
     x &= std::launch::deferred;
     assert(x == std::launch(0));
     x = std::launch::async;
     x |= std::launch::deferred;
-    assert(x == std::launch::any);
+    LIBCPP_ASSERT(x == std::launch::any);
     x ^= std::launch::deferred;
     assert(x == std::launch::async);
 #endif
diff --git a/test/std/thread/futures/futures.promise/copy_assign.fail.cpp b/test/std/thread/futures/futures.promise/copy_assign.fail.cpp
index e150ba0df65a..0311cf9b6b00 100644
--- a/test/std/thread/futures/futures.promise/copy_assign.fail.cpp
+++ b/test/std/thread/futures/futures.promise/copy_assign.fail.cpp
@@ -6,6 +6,8 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: libcpp-has-no-threads
 
 // <future>
 
diff --git a/test/std/thread/futures/futures.promise/copy_ctor.fail.cpp b/test/std/thread/futures/futures.promise/copy_ctor.fail.cpp
index 34becbc1259b..779fc5bfc7c4 100644
--- a/test/std/thread/futures/futures.promise/copy_ctor.fail.cpp
+++ b/test/std/thread/futures/futures.promise/copy_ctor.fail.cpp
@@ -6,6 +6,8 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: libcpp-has-no-threads
 
 // <future>
 
diff --git a/test/std/thread/futures/futures.promise/set_rvalue.pass.cpp b/test/std/thread/futures/futures.promise/set_rvalue.pass.cpp
index 9cce3f59550a..e0c6e15d98d5 100644
--- a/test/std/thread/futures/futures.promise/set_rvalue.pass.cpp
+++ b/test/std/thread/futures/futures.promise/set_rvalue.pass.cpp
@@ -7,8 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// XFAIL: libcpp-no-exceptions
-// UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: libcpp-has-no-threads, libcpp-no-exceptions
 
 // <future>
 
diff --git a/test/std/thread/futures/futures.tas/futures.task.members/assign_copy.fail.cpp b/test/std/thread/futures/futures.task/futures.task.members/assign_copy.fail.cpp
index 6c6418594d00..9449e1490270 100644
--- a/test/std/thread/futures/futures.tas/futures.task.members/assign_copy.fail.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/assign_copy.fail.cpp
@@ -6,7 +6,8 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-
+//
+// UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 
 // <future>
diff --git a/test/std/thread/futures/futures.tas/futures.task.members/assign_move.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/assign_move.pass.cpp
index 3f11d670bede..3f11d670bede 100644
--- a/test/std/thread/futures/futures.tas/futures.task.members/assign_move.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/assign_move.pass.cpp
diff --git a/test/std/thread/futures/futures.tas/futures.task.members/ctor1.fail.cpp b/test/std/thread/futures/futures.task/futures.task.members/ctor1.fail.cpp
index 7097d428962a..6d7d734bd5e7 100644
--- a/test/std/thread/futures/futures.tas/futures.task.members/ctor1.fail.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/ctor1.fail.cpp
@@ -6,7 +6,8 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-
+//
+// UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 
 // <future>
@@ -14,7 +15,7 @@
 // class packaged_task<R(ArgTypes...)>
 // template <class F>
 //   packaged_task(F&& f);
-// These constructors shall not participate in overload resolution if 
+// These constructors shall not participate in overload resolution if
 //    decay<F>::type is the same type as std::packaged_task<R(ArgTypes...)>.
 
 #include <future>
diff --git a/test/std/thread/futures/futures.tas/futures.task.members/ctor2.fail.cpp b/test/std/thread/futures/futures.task/futures.task.members/ctor2.fail.cpp
index feb7657bed37..984dcdc80b32 100644
--- a/test/std/thread/futures/futures.tas/futures.task.members/ctor2.fail.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/ctor2.fail.cpp
@@ -6,7 +6,8 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-
+//
+// UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 
 // <future>
@@ -14,7 +15,7 @@
 // class packaged_task<R(ArgTypes...)>
 // template <class F, class Allocator>
 //   packaged_task(allocator_arg_t, const Allocator& a, F&& f);
-// These constructors shall not participate in overload resolution if 
+// These constructors shall not participate in overload resolution if
 //    decay<F>::type is the same type as std::packaged_task<R(ArgTypes...)>.
 
 #include <future>
diff --git a/test/std/thread/futures/futures.tas/futures.task.members/ctor_copy.fail.cpp b/test/std/thread/futures/futures.task/futures.task.members/ctor_copy.fail.cpp
index 97624f90f3df..ff07db9a2e6f 100644
--- a/test/std/thread/futures/futures.tas/futures.task.members/ctor_copy.fail.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/ctor_copy.fail.cpp
@@ -6,7 +6,8 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-
+//
+// UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 
 // <future>
diff --git a/test/std/thread/futures/futures.tas/futures.task.members/ctor_default.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/ctor_default.pass.cpp
index ed147d74895b..ed147d74895b 100644
--- a/test/std/thread/futures/futures.tas/futures.task.members/ctor_default.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/ctor_default.pass.cpp
diff --git a/test/std/thread/futures/futures.tas/futures.task.members/ctor_func.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/ctor_func.pass.cpp
index 14ac7614bb8e..14ac7614bb8e 100644
--- a/test/std/thread/futures/futures.tas/futures.task.members/ctor_func.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/ctor_func.pass.cpp
diff --git a/test/std/thread/futures/futures.tas/futures.task.members/ctor_func_alloc.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/ctor_func_alloc.pass.cpp
index 39784876b8c3..39784876b8c3 100644
--- a/test/std/thread/futures/futures.tas/futures.task.members/ctor_func_alloc.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/ctor_func_alloc.pass.cpp
diff --git a/test/std/thread/futures/futures.tas/futures.task.members/ctor_move.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/ctor_move.pass.cpp
index d9951dca585a..d9951dca585a 100644
--- a/test/std/thread/futures/futures.tas/futures.task.members/ctor_move.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/ctor_move.pass.cpp
diff --git a/test/std/thread/futures/futures.tas/futures.task.members/dtor.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/dtor.pass.cpp
index 7fafd1005649..7fafd1005649 100644
--- a/test/std/thread/futures/futures.tas/futures.task.members/dtor.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/dtor.pass.cpp
diff --git a/test/std/thread/futures/futures.tas/futures.task.members/get_future.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/get_future.pass.cpp
index c8e5d6efd6b4..c8e5d6efd6b4 100644
--- a/test/std/thread/futures/futures.tas/futures.task.members/get_future.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/get_future.pass.cpp
diff --git a/test/std/thread/futures/futures.tas/futures.task.members/make_ready_at_thread_exit.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/make_ready_at_thread_exit.pass.cpp
index 54ac64458248..54ac64458248 100644
--- a/test/std/thread/futures/futures.tas/futures.task.members/make_ready_at_thread_exit.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/make_ready_at_thread_exit.pass.cpp
diff --git a/test/std/thread/futures/futures.tas/futures.task.members/operator.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/operator.pass.cpp
index 9ad1509517f6..9ad1509517f6 100644
--- a/test/std/thread/futures/futures.tas/futures.task.members/operator.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/operator.pass.cpp
diff --git a/test/std/thread/futures/futures.tas/futures.task.members/reset.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/reset.pass.cpp
index 02a567500ee2..02a567500ee2 100644
--- a/test/std/thread/futures/futures.tas/futures.task.members/reset.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/reset.pass.cpp
diff --git a/test/std/thread/futures/futures.tas/futures.task.members/swap.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/swap.pass.cpp
index eb0091c8e817..eb0091c8e817 100644
--- a/test/std/thread/futures/futures.tas/futures.task.members/swap.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/swap.pass.cpp
diff --git a/test/std/thread/futures/futures.tas/futures.task.nonmembers/swap.pass.cpp b/test/std/thread/futures/futures.task/futures.task.nonmembers/swap.pass.cpp
index d90d593a75bd..d90d593a75bd 100644
--- a/test/std/thread/futures/futures.tas/futures.task.nonmembers/swap.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.nonmembers/swap.pass.cpp
diff --git a/test/std/thread/futures/futures.tas/futures.task.nonmembers/uses_allocator.pass.cpp b/test/std/thread/futures/futures.task/futures.task.nonmembers/uses_allocator.pass.cpp
index bbe75de7f8a9..bbe75de7f8a9 100644
--- a/test/std/thread/futures/futures.tas/futures.task.nonmembers/uses_allocator.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.nonmembers/uses_allocator.pass.cpp
diff --git a/test/std/thread/futures/futures.unique_future/copy_assign.fail.cpp b/test/std/thread/futures/futures.unique_future/copy_assign.fail.cpp
index 781c9c9d6199..d20f0c38071f 100644
--- a/test/std/thread/futures/futures.unique_future/copy_assign.fail.cpp
+++ b/test/std/thread/futures/futures.unique_future/copy_assign.fail.cpp
@@ -6,6 +6,8 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: libcpp-has-no-threads
 
 // <future>
 
diff --git a/test/std/thread/futures/futures.unique_future/copy_ctor.fail.cpp b/test/std/thread/futures/futures.unique_future/copy_ctor.fail.cpp
index 0d7b5f5074d3..e1d85ac2cfdd 100644
--- a/test/std/thread/futures/futures.unique_future/copy_ctor.fail.cpp
+++ b/test/std/thread/futures/futures.unique_future/copy_ctor.fail.cpp
@@ -6,6 +6,8 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: libcpp-has-no-threads
 
 // <future>
 
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.fail.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.fail.cpp
index 246eb935c995..520c9730bdf7 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.fail.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-threads
+
 // <mutex>
 
 // template <class Mutex> class lock_guard;
@@ -14,35 +16,9 @@
 // explicit lock_guard(mutex_type& m);
 
 #include <mutex>
-#include <thread>
-#include <cstdlib>
-#include <cassert>
-
-std::mutex m;
-
-typedef std::chrono::system_clock Clock;
-typedef Clock::time_point time_point;
-typedef Clock::duration duration;
-typedef std::chrono::milliseconds ms;
-typedef std::chrono::nanoseconds ns;
-
-void f()
-{
-    time_point t0 = Clock::now();
-    time_point t1;
-    {
-    std::lock_guard<std::mutex> lg = m;
-    t1 = Clock::now();
-    }
-    ns d = t1 - t0 - ms(250);
-    assert(d < ns(2500000));  // within 2.5ms
-}
 
 int main()
 {
-    m.lock();
-    std::thread t(f);
-    std::this_thread::sleep_for(ms(250));
-    m.unlock();
-    t.join();
+    std::mutex m;
+    std::lock_guard<std::mutex> lg = m; // expected-error{{no viable conversion}}
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_adopt_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_adopt_lock.pass.cpp
new file mode 100644
index 000000000000..840af6788d04
--- /dev/null
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_adopt_lock.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: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
+
+// <mutex>
+
+// template <class ...Mutex> class lock_guard;
+
+// lock_guard(Mutex&..., adopt_lock_t);
+
+#define _LIBCPP_ABI_VARIADIC_LOCK_GUARD
+#include <mutex>
+#include <cassert>
+
+struct TestMutex {
+    bool locked = false;
+    TestMutex() = default;
+
+    void lock() { assert(!locked); locked = true; }
+    bool try_lock() { if (locked) return false; locked = true; return true; }
+    void unlock() { assert(locked); locked = false; }
+
+    TestMutex(TestMutex const&) = delete;
+    TestMutex& operator=(TestMutex const&) = delete;
+};
+
+int main()
+{
+    {
+        using LG = std::lock_guard<>;
+        LG lg(std::adopt_lock);
+    }
+    {
+        TestMutex m1, m2;
+        using LG = std::lock_guard<TestMutex, TestMutex>;
+        m1.lock(); m2.lock();
+        {
+            LG lg(m1, m2, std::adopt_lock);
+            assert(m1.locked && m2.locked);
+        }
+        assert(!m1.locked && !m2.locked);
+    }
+    {
+        TestMutex m1, m2, m3;
+        using LG = std::lock_guard<TestMutex, TestMutex, TestMutex>;
+        m1.lock(); m2.lock(); m3.lock();
+        {
+            LG lg(m1, m2, m3, std::adopt_lock);
+            assert(m1.locked && m2.locked && m3.locked);
+        }
+        assert(!m1.locked && !m2.locked && !m3.locked);
+    }
+
+}
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_assign.fail.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_assign.fail.cpp
new file mode 100644
index 000000000000..18193e000edc
--- /dev/null
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_assign.fail.cpp
@@ -0,0 +1,44 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
+
+// <mutex>
+
+// template <class ...Mutex> class lock_guard;
+
+// lock_guard& operator=(lock_guard const&) = delete;
+
+#define _LIBCPP_ABI_VARIADIC_LOCK_GUARD
+#include <mutex>
+
+int main()
+{
+    using M = std::mutex;
+    M m0, m1, m2;
+    M om0, om1, om2;
+    {
+        using LG = std::lock_guard<>;
+        LG lg1, lg2;
+        lg1 = lg2; // expected-error{{overload resolution selected deleted operator '='}}
+    }
+    {
+        using LG = std::lock_guard<M, M>;
+        LG lg1(m0, m1);
+        LG lg2(om0, om1);
+        lg1 = lg2; // expected-error{{overload resolution selected deleted operator '='}}
+    }
+    {
+        using LG = std::lock_guard<M, M, M>;
+        LG lg1(m0, m1, m2);
+        LG lg2(om0, om1, om2);
+        lg1 = lg2; // expected-error{{overload resolution selected deleted operator '='}}
+    }
+}
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_copy.fail.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_copy.fail.cpp
new file mode 100644
index 000000000000..6dc37e970fb6
--- /dev/null
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_copy.fail.cpp
@@ -0,0 +1,41 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
+
+// <mutex>
+
+// template <class ...Mutex> class lock_guard;
+
+// lock_guard(lock_guard const&) = delete;
+
+#define _LIBCPP_ABI_VARIADIC_LOCK_GUARD
+#include <mutex>
+
+int main()
+{
+    using M = std::mutex;
+    M m0, m1, m2;
+    {
+        using LG = std::lock_guard<>;
+        const LG Orig;
+        LG Copy(Orig); // expected-error{{call to deleted constructor of 'LG'}}
+    }
+    {
+        using LG = std::lock_guard<M, M>;
+        const LG Orig(m0, m1);
+        LG Copy(Orig); // expected-error{{call to deleted constructor of 'LG'}}
+    }
+    {
+        using LG = std::lock_guard<M, M, M>;
+        const LG Orig(m0, m1, m2);
+        LG Copy(Orig); // expected-error{{call to deleted constructor of 'LG'}}
+    }
+}
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_mutex.fail.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_mutex.fail.cpp
new file mode 100644
index 000000000000..866538a2834f
--- /dev/null
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_mutex.fail.cpp
@@ -0,0 +1,47 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
+
+// <mutex>
+
+// template <class ...Mutex> class lock_guard;
+
+// explicit lock_guard(Mutex&...);
+
+#define _LIBCPP_ABI_VARIADIC_LOCK_GUARD
+#include <mutex>
+
+template <class LG>
+void test_conversion(LG) {}
+
+int main()
+{
+    using M = std::mutex;
+    M m0, m1, m2;
+    M n0, n1, n2;
+    {
+        using LG = std::lock_guard<>;
+        LG lg = {}; // expected-error{{chosen constructor is explicit in copy-initialization}}
+        test_conversion<LG>({}); // expected-error{{no matching function for call}}
+        ((void)lg);
+    }
+    {
+        using LG = std::lock_guard<M, M>;
+        LG lg = {m0, m1}; // expected-error{{chosen constructor is explicit in copy-initialization}}
+        test_conversion<LG>({n0, n1}); // expected-error{{no matching function for call}}
+        ((void)lg);
+    }
+    {
+        using LG = std::lock_guard<M, M, M>;
+        LG lg = {m0, m1, m2}; // expected-error{{chosen constructor is explicit in copy-initialization}}
+        test_conversion<LG>({n0, n1, n2}); // expected-error{{no matching function for call}}
+    }
+}
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_mutex.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_mutex.pass.cpp
new file mode 100644
index 000000000000..4910d837cae3
--- /dev/null
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_mutex.pass.cpp
@@ -0,0 +1,115 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
+
+// <mutex>
+
+// template <class ...Mutex> class lock_guard;
+
+// explicit lock_guard(mutex_type& m);
+
+#define _LIBCPP_ABI_VARIADIC_LOCK_GUARD
+#include <mutex>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct TestMutex {
+    bool locked = false;
+    TestMutex() = default;
+    ~TestMutex() { assert(!locked); }
+
+    void lock() { assert(!locked); locked = true; }
+    bool try_lock() { if (locked) return false; locked = true; return true; }
+    void unlock() { assert(locked); locked = false; }
+
+    TestMutex(TestMutex const&) = delete;
+    TestMutex& operator=(TestMutex const&) = delete;
+};
+
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+struct TestMutexThrows {
+    bool locked = false;
+    bool throws_on_lock = false;
+
+    TestMutexThrows() = default;
+    ~TestMutexThrows() { assert(!locked); }
+
+    void lock() {
+        assert(!locked);
+        if (throws_on_lock) {
+            throw 42;
+        }
+        locked = true;
+    }
+
+    bool try_lock() {
+        if (locked) return false;
+        lock();
+        return true;
+    }
+
+    void unlock() { assert(locked); locked = false; }
+
+    TestMutexThrows(TestMutexThrows const&) = delete;
+    TestMutexThrows& operator=(TestMutexThrows const&) = delete;
+};
+#endif // !defined(TEST_HAS_NO_EXCEPTIONS)
+
+int main()
+{
+    {
+        using LG = std::lock_guard<>;
+        LG lg;
+    }
+    {
+        using LG = std::lock_guard<TestMutex, TestMutex>;
+        TestMutex m1, m2;
+        {
+            LG lg(m1, m2);
+            assert(m1.locked && m2.locked);
+        }
+        assert(!m1.locked && !m2.locked);
+    }
+    {
+        using LG = std::lock_guard<TestMutex, TestMutex, TestMutex>;
+        TestMutex m1, m2, m3;
+        {
+            LG lg(m1, m2, m3);
+            assert(m1.locked && m2.locked && m3.locked);
+        }
+        assert(!m1.locked && !m2.locked && !m3.locked);
+    }
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+    {
+        using MT = TestMutexThrows;
+        using LG = std::lock_guard<MT, MT>;
+        MT m1, m2;
+        m1.throws_on_lock = true;
+        try {
+            LG lg(m1, m2);
+            assert(false);
+        } catch (int) {}
+        assert(!m1.locked && !m2.locked);
+    }
+    {
+        using MT = TestMutexThrows;
+        using LG = std::lock_guard<MT, MT, MT>;
+        MT m1, m2, m3;
+        m2.throws_on_lock = true;
+        try {
+            LG lg(m1, m2, m3);
+            assert(false);
+        } catch (int) {}
+        assert(!m1.locked && !m2.locked && !m3.locked);
+    }
+#endif
+}
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_mutex_cxx03.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_mutex_cxx03.pass.cpp
new file mode 100644
index 000000000000..3c134e0b8861
--- /dev/null
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_mutex_cxx03.pass.cpp
@@ -0,0 +1,21 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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: libcpp-has-no-threads
+
+// <mutex>
+
+// template <class ...Mutex> class lock_guard;
+
+// Test that the variadic lock guard implementation compiles in all standard
+// dialects, including C++03, even though it is forward declared using
+// variadic templates.
+
+#define _LIBCPP_ABI_VARIADIC_LOCK_GUARD
+#include "mutex.pass.cpp" // Use the existing non-variadic test
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_types.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_types.pass.cpp
new file mode 100644
index 000000000000..2b06742a673e
--- /dev/null
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_types.pass.cpp
@@ -0,0 +1,78 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
+
+// <mutex>
+
+// template <class Mutex>
+// class lock_guard
+// {
+// public:
+//     typedef Mutex mutex_type;
+//     ...
+// };
+
+#define _LIBCPP_ABI_VARIADIC_LOCK_GUARD
+#include <mutex>
+#include <type_traits>
+
+struct NAT {};
+
+template <class LG>
+auto test_typedef(int) -> typename LG::mutex_type;
+
+template <class LG>
+auto test_typedef(...) -> NAT;
+
+template <class LG>
+constexpr bool has_mutex_type() {
+    return !std::is_same<decltype(test_typedef<LG>(0)), NAT>::value;
+}
+
+int main()
+{
+    {
+        using T = std::lock_guard<>;
+        static_assert(!has_mutex_type<T>(), "");
+    }
+    {
+        using M1 = std::mutex;
+        using T = std::lock_guard<M1>;
+        static_assert(std::is_same<T::mutex_type, M1>::value, "");
+    }
+    {
+        using M1 = std::recursive_mutex;
+        using T = std::lock_guard<M1>;
+        static_assert(std::is_same<T::mutex_type, M1>::value, "");
+    }
+    {
+        using M1 = std::mutex;
+        using M2 = std::recursive_mutex;
+        using T = std::lock_guard<M1, M2>;
+        static_assert(!has_mutex_type<T>(), "");
+    }
+    {
+        using M1 = std::mutex;
+        using M2 = std::recursive_mutex;
+        using T = std::lock_guard<M1, M1, M2>;
+        static_assert(!has_mutex_type<T>(), "");
+    }
+    {
+        using M1 = std::mutex;
+        using T = std::lock_guard<M1, M1>;
+        static_assert(!has_mutex_type<T>(), "");
+    }
+    {
+        using M1 = std::recursive_mutex;
+        using T = std::lock_guard<M1, M1, M1>;
+        static_assert(!has_mutex_type<T>(), "");
+    }
+}
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/copy_assign.fail.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/copy_assign.fail.cpp
index 446807f3f333..79f43e860ca2 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/copy_assign.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/copy_assign.fail.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <shared_mutex>
 
 // template <class Mutex> class shared_lock;
@@ -15,20 +16,12 @@
 
 #include <shared_mutex>
 
-#if _LIBCPP_STD_VER > 11
-
 std::shared_timed_mutex m0;
 std::shared_timed_mutex m1;
 
-#endif  // _LIBCPP_STD_VER > 11
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     std::shared_lock<std::shared_timed_mutex> lk0(m0);
     std::shared_lock<std::shared_timed_mutex> lk1(m1);
     lk1 = lk0;
-#else
-#   error
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/copy_ctor.fail.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/copy_ctor.fail.cpp
index 370c1fa4e336..d6bf57947afe 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/copy_ctor.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/copy_ctor.fail.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <shared_mutex>
 
 // template <class Mutex> class shared_lock;
@@ -15,16 +16,10 @@
 
 #include <shared_mutex>
 
-#if _LIBCPP_STD_VER > 11
 std::shared_timed_mutex m;
-#endif  // _LIBCPP_STD_VER > 11
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     std::shared_lock<std::shared_timed_mutex> lk0(m);
     std::shared_lock<std::shared_timed_mutex> lk = lk0;
-#else
-#   error
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_assign.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_assign.pass.cpp
index 15c193c60b5d..bd707bb90ce1 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_assign.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_assign.pass.cpp
@@ -18,17 +18,33 @@
 
 #include <shared_mutex>
 #include <cassert>
+#include "nasty_containers.hpp"
 
-std::shared_timed_mutex m0;
-std::shared_timed_mutex m1;
 
 int main()
 {
-    std::shared_lock<std::shared_timed_mutex> lk0(m0);
-    std::shared_lock<std::shared_timed_mutex> lk1(m1);
+    {
+    typedef std::shared_timed_mutex M;
+	M m0;
+	M m1;
+    std::shared_lock<M> lk0(m0);
+    std::shared_lock<M> lk1(m1);
     lk1 = std::move(lk0);
-    assert(lk1.mutex() == &m0);
+    assert(lk1.mutex() == std::addressof(m0));
     assert(lk1.owns_lock() == true);
     assert(lk0.mutex() == nullptr);
     assert(lk0.owns_lock() == false);
+    }
+    {
+    typedef nasty_mutex M;
+	M m0;
+	M m1;
+    std::shared_lock<M> lk0(m0);
+    std::shared_lock<M> lk1(m1);
+    lk1 = std::move(lk0);
+    assert(lk1.mutex() == std::addressof(m0));
+    assert(lk1.owns_lock() == true);
+    assert(lk0.mutex() == nullptr);
+    assert(lk0.owns_lock() == false);
+    }
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_ctor.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_ctor.pass.cpp
index 4f4f6a5e9fbd..c29a3fb04d0f 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_ctor.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_ctor.pass.cpp
@@ -18,14 +18,28 @@
 
 #include <shared_mutex>
 #include <cassert>
+#include "nasty_containers.hpp"
 
 int main()
 {
-    std::shared_timed_mutex m;
-    std::shared_lock<std::shared_timed_mutex> lk0(m);
-    std::shared_lock<std::shared_timed_mutex> lk = std::move(lk0);
-    assert(lk.mutex() == &m);
+    {
+    typedef std::shared_timed_mutex M;
+    M m;
+    std::shared_lock<M> lk0(m);
+    std::shared_lock<M> lk = std::move(lk0);
+    assert(lk.mutex() == std::addressof(m));
     assert(lk.owns_lock() == true);
     assert(lk0.mutex() == nullptr);
     assert(lk0.owns_lock() == false);
+    }
+    {
+    typedef nasty_mutex M;
+    M m;
+    std::shared_lock<M> lk0(m);
+    std::shared_lock<M> lk = std::move(lk0);
+    assert(lk.mutex() == std::addressof(m));
+    assert(lk.owns_lock() == true);
+    assert(lk0.mutex() == nullptr);
+    assert(lk0.owns_lock() == false);
+    }
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_adopt_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_adopt_lock.pass.cpp
index 995210221065..341f0ce7efd2 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_adopt_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_adopt_lock.pass.cpp
@@ -18,12 +18,24 @@
 
 #include <shared_mutex>
 #include <cassert>
+#include "nasty_containers.hpp"
 
 int main()
 {
-    std::shared_timed_mutex m;
-    m.lock_shared();
-    std::shared_lock<std::shared_timed_mutex> lk(m, std::adopt_lock);
-    assert(lk.mutex() == &m);
+    {
+    typedef std::shared_timed_mutex M;
+    M m;
+    m.lock();
+    std::unique_lock<M> lk(m, std::adopt_lock);
+    assert(lk.mutex() == std::addressof(m));
     assert(lk.owns_lock() == true);
+    }
+    {
+    typedef nasty_mutex M;
+    M m;
+    m.lock();
+    std::unique_lock<M> lk(m, std::adopt_lock);
+    assert(lk.mutex() == std::addressof(m));
+    assert(lk.owns_lock() == true);
+    }
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_defer_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_defer_lock.pass.cpp
index d81796b95bf3..5fbb7244ef8e 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_defer_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_defer_lock.pass.cpp
@@ -18,11 +18,22 @@
 
 #include <shared_mutex>
 #include <cassert>
+#include "nasty_containers.hpp"
 
 int main()
 {
-    std::shared_timed_mutex m;
-    std::shared_lock<std::shared_timed_mutex> lk(m, std::defer_lock);
-    assert(lk.mutex() == &m);
+    {
+    typedef std::shared_timed_mutex M;
+    M m;
+    std::unique_lock<M> lk(m, std::defer_lock);
+    assert(lk.mutex() == std::addressof(m));
     assert(lk.owns_lock() == false);
+    }
+    {
+    typedef nasty_mutex M;
+    M m;
+    std::unique_lock<M> lk(m, std::defer_lock);
+    assert(lk.mutex() == std::addressof(m));
+    assert(lk.owns_lock() == false);
+    }
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_assign.fail.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_assign.fail.cpp
index 4f477449d6a2..8d864ea8e7da 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_assign.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_assign.fail.cpp
@@ -16,16 +16,18 @@
 #include <mutex>
 #include <cassert>
 
-std::mutex m0;
-std::mutex m1;
-
 int main()
 {
-    std::unique_lock<std::mutex> lk0(m0);
-    std::unique_lock<std::mutex> lk1(m1);
+    {
+    typedef std::mutex M;
+	M m0;
+	M m1;
+    std::unique_lock<M> lk0(m0);
+    std::unique_lock<M> lk1(m1);
     lk1 = lk0;
     assert(lk1.mutex() == &m0);
     assert(lk1.owns_lock() == true);
     assert(lk0.mutex() == nullptr);
     assert(lk0.owns_lock() == false);
+    }
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_ctor.fail.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_ctor.fail.cpp
index 4888fe90d92c..067302127cad 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_ctor.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_ctor.fail.cpp
@@ -16,14 +16,16 @@
 #include <mutex>
 #include <cassert>
 
-std::mutex m;
-
 int main()
 {
-    std::unique_lock<std::mutex> lk0(m);
-    std::unique_lock<std::mutex> lk = lk0;
+    {
+    typedef std::mutex M;
+    M m;
+    std::unique_lock<M> lk0(m);
+    std::unique_lock<M> lk = lk0;
     assert(lk.mutex() == &m);
     assert(lk.owns_lock() == true);
     assert(lk0.mutex() == nullptr);
     assert(lk0.owns_lock() == false);
+    }
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_assign.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_assign.pass.cpp
index 4dff853088ac..e5db685e46e7 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_assign.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_assign.pass.cpp
@@ -17,19 +17,34 @@
 
 #include <mutex>
 #include <cassert>
-
-std::mutex m0;
-std::mutex m1;
+#include "nasty_containers.hpp"
 
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    std::unique_lock<std::mutex> lk0(m0);
-    std::unique_lock<std::mutex> lk1(m1);
+    {
+    typedef std::mutex M;
+	M m0;
+	M m1;
+    std::unique_lock<M> lk0(m0);
+    std::unique_lock<M> lk1(m1);
+    lk1 = std::move(lk0);
+    assert(lk1.mutex() == std::addressof(m0));
+    assert(lk1.owns_lock() == true);
+    assert(lk0.mutex() == nullptr);
+    assert(lk0.owns_lock() == false);
+    }
+    {
+    typedef nasty_mutex M;
+	M m0;
+	M m1;
+    std::unique_lock<M> lk0(m0);
+    std::unique_lock<M> lk1(m1);
     lk1 = std::move(lk0);
-    assert(lk1.mutex() == &m0);
+    assert(lk1.mutex() == std::addressof(m0));
     assert(lk1.owns_lock() == true);
     assert(lk0.mutex() == nullptr);
     assert(lk0.owns_lock() == false);
+    }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_ctor.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_ctor.pass.cpp
index aa640ee6d746..427deabc5a59 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_ctor.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_ctor.pass.cpp
@@ -17,17 +17,30 @@
 
 #include <mutex>
 #include <cassert>
-
-std::mutex m;
+#include "nasty_containers.hpp"
 
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    std::unique_lock<std::mutex> lk0(m);
-    std::unique_lock<std::mutex> lk = std::move(lk0);
-    assert(lk.mutex() == &m);
+    {
+    typedef std::mutex M;
+    M m;
+    std::unique_lock<M> lk0(m);
+    std::unique_lock<M> lk = std::move(lk0);
+    assert(lk.mutex() == std::addressof(m));
+    assert(lk.owns_lock() == true);
+    assert(lk0.mutex() == nullptr);
+    assert(lk0.owns_lock() == false);
+    }
+    {
+    typedef nasty_mutex M;
+    M m;
+    std::unique_lock<M> lk0(m);
+    std::unique_lock<M> lk = std::move(lk0);
+    assert(lk.mutex() == std::addressof(m));
     assert(lk.owns_lock() == true);
     assert(lk0.mutex() == nullptr);
     assert(lk0.owns_lock() == false);
+    }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_adopt_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_adopt_lock.pass.cpp
index 9c3a7b6505a4..20f7d249b6f4 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_adopt_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_adopt_lock.pass.cpp
@@ -17,12 +17,24 @@
 
 #include <mutex>
 #include <cassert>
+#include "nasty_containers.hpp"
 
 int main()
 {
-    std::mutex m;
+    {
+    typedef std::mutex M;
+    M m;
     m.lock();
-    std::unique_lock<std::mutex> lk(m, std::adopt_lock);
-    assert(lk.mutex() == &m);
+    std::unique_lock<M> lk(m, std::adopt_lock);
+    assert(lk.mutex() == std::addressof(m));
     assert(lk.owns_lock() == true);
+    }
+    {
+    typedef nasty_mutex M;
+    M m;
+    m.lock();
+    std::unique_lock<M> lk(m, std::adopt_lock);
+    assert(lk.mutex() == std::addressof(m));
+    assert(lk.owns_lock() == true);
+    }
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_defer_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_defer_lock.pass.cpp
index bf622311f013..242dacb1eb92 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_defer_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_defer_lock.pass.cpp
@@ -17,11 +17,22 @@
 
 #include <mutex>
 #include <cassert>
+#include "nasty_containers.hpp"
 
 int main()
 {
-    std::mutex m;
-    std::unique_lock<std::mutex> lk(m, std::defer_lock);
-    assert(lk.mutex() == &m);
+    {
+    typedef std::mutex M;
+    M m;
+    std::unique_lock<M> lk(m, std::defer_lock);
+    assert(lk.mutex() == std::addressof(m));
     assert(lk.owns_lock() == false);
+    }
+    {
+    typedef nasty_mutex M;
+    M m;
+    std::unique_lock<M> lk(m, std::defer_lock);
+    assert(lk.mutex() == std::addressof(m));
+    assert(lk.owns_lock() == false);
+    }
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/assign.fail.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/assign.fail.cpp
index 5c67a34ab52b..81995f6c8888 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/assign.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/assign.fail.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
+// UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
 // <shared_mutex>
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/copy.fail.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/copy.fail.cpp
index c7cac6041c82..e4bee4bb7ad1 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/copy.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/copy.fail.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
+// UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
 // <shared_mutex>
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/assign.fail.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/assign.fail.cpp
index 528aaca6d9e1..0c5bfa804bea 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/assign.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/assign.fail.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <shared_mutex>
 
 // class shared_timed_mutex;
@@ -17,11 +18,7 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     std::shared_timed_mutex m0;
     std::shared_timed_mutex m1;
     m1 = m0;
-#else
-#   error
-#endif
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/copy.fail.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/copy.fail.cpp
index dbf01002e691..3656ec62ec17 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/copy.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/copy.fail.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <shared_mutex>
 
 // class shared_timed_mutex;
@@ -17,10 +18,6 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     std::shared_timed_mutex m0;
     std::shared_timed_mutex m1(m0);
-#else
-#   error
-#endif
 }
diff --git a/test/std/thread/thread.mutex/thread.once/thread.once.callonce/call_once.pass.cpp b/test/std/thread/thread.mutex/thread.once/thread.once.callonce/call_once.pass.cpp
index afc318cc3d7a..71b054fced88 100644
--- a/test/std/thread/thread.mutex/thread.once/thread.once.callonce/call_once.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.once/thread.once.callonce/call_once.pass.cpp
@@ -21,6 +21,8 @@
 #include <thread>
 #include <cassert>
 
+#include "test_macros.h"
+
 typedef std::chrono::milliseconds ms;
 
 std::once_flag flg0;
@@ -171,7 +173,7 @@ public:
     void operator()(int&) {}
 };
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
 // reference qualifiers on functions are a C++11 extension
 struct RefQual
 {
@@ -240,7 +242,7 @@ int main()
         int i = 0;
         std::call_once(f, NonCopyable(), i);
     }
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
 // reference qualifiers on functions are a C++11 extension
     {
         std::once_flag f1, f2;
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/F.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/F.pass.cpp
index 3de15af8929b..5dd6a40a0eb7 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/F.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/F.pass.cpp
@@ -20,23 +20,30 @@
 
 #include <thread>
 #include <new>
+#include <atomic>
 #include <cstdlib>
 #include <cassert>
 
 #include "test_macros.h"
 
-unsigned throw_one = 0xFFFF;
+std::atomic<unsigned> throw_one(0xFFFF);
+std::atomic<unsigned> outstanding_new(0);
+
 
 void* operator new(std::size_t s) throw(std::bad_alloc)
 {
     if (throw_one == 0)
         throw std::bad_alloc();
     --throw_one;
-    return std::malloc(s);
+    ++outstanding_new;
+    void* ret = std::malloc(s);
+    if (!ret) std::abort(); // placate MSVC's unchecked malloc warning
+    return ret;
 }
 
 void  operator delete(void* p) throw()
 {
+    --outstanding_new;
     std::free(p);
 }
 
@@ -94,27 +101,58 @@ public:
 
 #endif
 
-int main()
-{
+// Test throwing std::bad_alloc
+//-----------------------------
+// Concerns:
+//  A Each allocation performed during thread construction should be performed
+//    in the parent thread so that std::terminate is not called if
+//    std::bad_alloc is thrown by new.
+//  B std::threads constructor should properly handle exceptions and not leak
+//    memory.
+// Plan:
+//  1 Create a thread and count the number of allocations, 'N', it performs.
+//  2 For each allocation performed run a test where that allocation throws.
+//    2.1 check that the exception can be caught in the parent thread.
+//    2.2 Check that the functor has not been called.
+//    2.3 Check that no memory allocated by the creation of the thread is leaked.
+//  3 Finally check that a thread runs successfully if we throw after 'N+1'
+//    allocations.
+void test_throwing_new_during_thread_creation() {
+    throw_one = 0xFFF;
     {
         std::thread t(f);
         t.join();
-        assert(f_run == true);
     }
-    f_run = false;
-    {
-        try
-        {
-            throw_one = 0;
+    const int numAllocs = 0xFFF - throw_one;
+    // i <= numAllocs means the last iteration is expected not to throw.
+    for (int i=0; i <= numAllocs; ++i) {
+        throw_one = i;
+        f_run = false;
+        unsigned old_outstanding = outstanding_new;
+        try {
             std::thread t(f);
-            assert(false);
-        }
-        catch (...)
-        {
-            throw_one = 0xFFFF;
-            assert(!f_run);
+            assert(i == numAllocs); // Only final iteration will not throw.
+            t.join();
+            assert(f_run);
+        } catch (std::bad_alloc const&) {
+            assert(i < numAllocs);
+            assert(!f_run); // (2.2)
         }
+        assert(old_outstanding == outstanding_new); // (2.3)
+    }
+    f_run = false;
+    throw_one = 0xFFF;
+}
+
+int main()
+{
+    test_throwing_new_during_thread_creation();
+    {
+        std::thread t(f);
+        t.join();
+        assert(f_run == true);
     }
+
     {
         assert(G::n_alive == 0);
         assert(!G::op_run);
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/constr.fail.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/constr.fail.cpp
index a331add96263..54fc0b80280c 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/constr.fail.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/constr.fail.cpp
@@ -12,7 +12,7 @@
 // class thread
 //     template <class _Fp, class ..._Args,
 //         explicit thread(_Fp&& __f, _Args&&... __args);
-//  This constructor shall not participate in overload resolution 
+//  This constructor shall not participate in overload resolution
 //       if decay<F>::type is the same type as std::thread.
 
 
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/detach.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/detach.pass.cpp
index 726395d99044..3dd7c6a6014c 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/detach.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/detach.pass.cpp
@@ -17,8 +17,11 @@
 
 #include <thread>
 #include <atomic>
+#include <system_error>
 #include <cassert>
 
+#include "test_macros.h"
+
 std::atomic_bool done(false);
 
 class G
@@ -57,6 +60,8 @@ public:
 int G::n_alive = 0;
 bool G::op_run = false;
 
+void foo() {}
+
 int main()
 {
     {
@@ -70,4 +75,16 @@ int main()
         assert(G::n_alive == 1);
     }
     assert(G::n_alive == 0);
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    {
+        std::thread t0(foo);
+        assert(t0.joinable());
+        t0.detach();
+        assert(!t0.joinable());
+        try {
+            t0.detach();
+        } catch (std::system_error const&) {
+        }
+    }
+#endif
 }
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/join.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/join.pass.cpp
index 0512e49dcb33..f0c3ef74c9ab 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/join.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/join.pass.cpp
@@ -19,6 +19,9 @@
 #include <new>
 #include <cstdlib>
 #include <cassert>
+#include <system_error>
+
+#include "test_macros.h"
 
 class G
 {
@@ -42,6 +45,8 @@ public:
 int G::n_alive = 0;
 bool G::op_run = false;
 
+void foo() {}
+
 int main()
 {
     {
@@ -50,5 +55,23 @@ int main()
         assert(t0.joinable());
         t0.join();
         assert(!t0.joinable());
+#ifndef TEST_HAS_NO_EXCEPTIONS
+        try {
+            t0.join();
+            assert(false);
+        } catch (std::system_error const&) {
+        }
+#endif
+    }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    {
+        std::thread t0(foo);
+        t0.detach();
+        try {
+            t0.join();
+            assert(false);
+        } catch (std::system_error const&) {
+        }
     }
+#endif
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/allocator_pointers.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/allocator_pointers.pass.cpp
index e165d9836db0..81c366e0668f 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/allocator_pointers.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/allocator_pointers.pass.cpp
@@ -11,7 +11,9 @@
 #include <memory>
 #include <cassert>
 
-#if __cplusplus >= 201103L
+#include "test_macros.h"
+
+#if TEST_STD_VER >= 11
 // #include <memory>
 //
 // template <class Alloc>
@@ -20,7 +22,7 @@
 //     typedef Alloc                        allocator_type;
 //     typedef typename allocator_type::value_type
 //                                          value_type;
-// 
+//
 //     typedef Alloc::pointer | value_type* pointer;
 //     typedef Alloc::const_pointer
 //           | pointer_traits<pointer>::rebind<const value_type>
@@ -37,7 +39,10 @@ void test_pointer()
 {
      typename std::allocator_traits<Alloc>::pointer        vp;
      typename std::allocator_traits<Alloc>::const_pointer cvp;
-     
+
+     ((void)vp); // Prevent unused warning
+     ((void)cvp); // Prevent unused warning
+
      static_assert(std::is_same<bool, decltype( vp ==  vp)>::value, "");
      static_assert(std::is_same<bool, decltype( vp !=  vp)>::value, "");
      static_assert(std::is_same<bool, decltype( vp >   vp)>::value, "");
@@ -71,7 +76,10 @@ void test_void_pointer()
 {
      typename std::allocator_traits<Alloc>::void_pointer        vp;
      typename std::allocator_traits<Alloc>::const_void_pointer cvp;
-     
+
+     ((void)vp); // Prevent unused warning
+     ((void)cvp); // Prevent unused warning
+
      static_assert(std::is_same<bool, decltype( vp ==  vp)>::value, "");
      static_assert(std::is_same<bool, decltype( vp !=  vp)>::value, "");
      static_assert(std::is_same<bool, decltype( vp >   vp)>::value, "");
@@ -110,7 +118,7 @@ int main()
 
     test_void_pointer<std::scoped_allocator_adaptor<std::allocator<char>>> ();
     test_void_pointer<std::scoped_allocator_adaptor<std::allocator<int>>> ();
-    test_void_pointer<std::scoped_allocator_adaptor<std::allocator<Foo>>> ();   
+    test_void_pointer<std::scoped_allocator_adaptor<std::allocator<Foo>>> ();
 }
 #else
 int main() {}
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/is_always_equal.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/is_always_equal.pass.cpp
index e19e731f6cf2..90fe944125b5 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/is_always_equal.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/is_always_equal.pass.cpp
@@ -32,7 +32,7 @@ int main()
     static_assert( (std::is_same<
     		std::allocator_traits<min_allocator<int>>::is_always_equal, std::true_type>::value
     		), "" );
-    
+
     // wrapping one allocator
     static_assert(
         (std::is_same<
@@ -51,14 +51,14 @@ int main()
     static_assert((
             std::scoped_allocator_adaptor<A1<int>, A2<int>>::is_always_equal::value ==
             ( std::allocator_traits<A1<int>>::is_always_equal::value &&
-              std::allocator_traits<A2<int>>::is_always_equal::value)    
+              std::allocator_traits<A2<int>>::is_always_equal::value)
         ), "");
 
     // wrapping two allocators (check the values instead of the types)
     static_assert((
             std::scoped_allocator_adaptor<A1<int>, min_allocator<int>>::is_always_equal::value ==
             ( std::allocator_traits<A1<int>>::is_always_equal::value &&
-              std::allocator_traits<min_allocator<int>>::is_always_equal::value)    
+              std::allocator_traits<min_allocator<int>>::is_always_equal::value)
         ), "");
 
 
@@ -66,8 +66,8 @@ int main()
     static_assert((
             std::scoped_allocator_adaptor<A1<int>, A2<int>, A3<int>>::is_always_equal::value ==
             ( std::allocator_traits<A1<int>>::is_always_equal::value &&
-              std::allocator_traits<A2<int>>::is_always_equal::value &&    
-              std::allocator_traits<A3<int>>::is_always_equal::value)    
+              std::allocator_traits<A2<int>>::is_always_equal::value &&
+              std::allocator_traits<A3<int>>::is_always_equal::value)
         ), "");
 
 
diff --git a/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/eq.pass.cpp b/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/eq.pass.cpp
index 8d4cb6abe84a..51dd67f9ffdc 100644
--- a/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/eq.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/eq.pass.cpp
@@ -16,7 +16,7 @@
 //     bool
 //     operator==(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a,
 //                const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b);
-// 
+//
 // template <class OuterA1, class OuterA2, class... InnerAllocs>
 //     bool
 //     operator!=(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a,
diff --git a/test/std/utilities/function.objects/arithmetic.operations/plus.pass.cpp b/test/std/utilities/function.objects/arithmetic.operations/plus.pass.cpp
index 3c093fc093c3..ce544c78b676 100644
--- a/test/std/utilities/function.objects/arithmetic.operations/plus.pass.cpp
+++ b/test/std/utilities/function.objects/arithmetic.operations/plus.pass.cpp
@@ -29,7 +29,7 @@ int main()
     assert(f2(3,2) == 5);
     assert(f2(3.0, 2) == 5);
     assert(f2(3, 2.5) == 5.5);
-    
+
     constexpr int foo = std::plus<int> () (3, 2);
     static_assert ( foo == 5, "" );
 
diff --git a/test/std/utilities/function.objects/arithmetic.operations/transparent.pass.cpp b/test/std/utilities/function.objects/arithmetic.operations/transparent.pass.cpp
index 72b4b4a0a1fe..b85f439ba7a0 100644
--- a/test/std/utilities/function.objects/arithmetic.operations/transparent.pass.cpp
+++ b/test/std/utilities/function.objects/arithmetic.operations/transparent.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 #include <functional>
 #include <string>
 
@@ -22,9 +23,8 @@ public:
 };
 
 
-int main () {
-#if _LIBCPP_STD_VER > 11
-
+int main ()
+{
     static_assert ( !is_transparent<std::plus<int>>::value, "" );
     static_assert ( !is_transparent<std::plus<std::string>>::value, "" );
     static_assert (  is_transparent<std::plus<void>>::value, "" );
@@ -54,8 +54,6 @@ int main () {
     static_assert ( !is_transparent<std::negate<std::string>>::value, "" );
     static_assert (  is_transparent<std::negate<void>>::value, "" );
     static_assert (  is_transparent<std::negate<>>::value, "" );
-    
-#endif
 
     return 0;
-    }
+}
diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/PR23141_invoke_not_constexpr.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/PR23141_invoke_not_constexpr.pass.cpp
new file mode 100644
index 000000000000..5e347c4c5715
--- /dev/null
+++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/PR23141_invoke_not_constexpr.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
+
+// <functional>
+
+// template<CopyConstructible Fn, CopyConstructible... Types>
+//   unspecified bind(Fn, Types...);
+// template<Returnable R, CopyConstructible Fn, CopyConstructible... Types>
+//   unspecified bind(Fn, Types...);
+
+// https://llvm.org/bugs/show_bug.cgi?id=23141
+#include <functional>
+#include <type_traits>
+
+struct Fun
+{
+  template<typename T, typename U>
+  void operator()(T &&, U &&) const
+  {
+    static_assert(std::is_same<U, int &>::value, "");
+  }
+};
+
+int main()
+{
+    std::bind(Fun{}, std::placeholders::_1, 42)("hello");
+}
diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/bind_return_type.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/bind_return_type.pass.cpp
new file mode 100644
index 000000000000..63d3c9b0de92
--- /dev/null
+++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/bind_return_type.pass.cpp
@@ -0,0 +1,131 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <functional>
+
+// template<CopyConstructible Fn, CopyConstructible... Types>
+//   unspecified bind(Fn, Types...);
+// template<Returnable R, CopyConstructible Fn, CopyConstructible... Types>
+//   unspecified bind(Fn, Types...);
+
+// Check that the call operators have the proper return type and that they
+// only SFINAE away when too few arguments are provided. Otherwise they should
+// be well formed and should ignore any additional arguments.
+
+#include <functional>
+#include <type_traits>
+#include <cassert>
+
+int dummy = 42;
+
+int return_value(int) { return dummy; }
+int& return_lvalue(int) { return dummy; }
+const int& return_const_lvalue(int) { return dummy; }
+int&& return_rvalue(int) { return std::move(dummy); }
+const int&& return_const_rvalue(int) { return std::move(dummy); }
+
+template <class Bind, class ...Args>
+auto CheckCallImp(int)
+    -> decltype((std::declval<Bind>()(std::declval<Args>()...)), std::true_type{});
+
+template <class Bind, class ...>
+auto CheckCallImp(long) -> std::false_type;
+
+template <class ...Args>
+constexpr bool CheckCall() {
+    return decltype(CheckCallImp<Args...>(0))::value;
+}
+
+template <class Expect, class Fn>
+void do_test(Fn* func) {
+    using namespace std::placeholders;
+    auto ret = std::bind(func, _1);
+    auto ret_r = std::bind<Expect>(func, _1);
+    using Bind = decltype(ret);
+    using BindR = decltype(ret_r);
+
+    using Ret = decltype(ret(42));
+    using Ret2 = decltype(ret(42, 43)); // Test that the extra argument is discarded.
+    using RetR = decltype(ret_r(42));
+    using RetR2 = decltype(ret_r(42, 43));
+
+    static_assert(std::is_same<Ret, Expect>::value, "");
+    static_assert(std::is_same<Ret2, Expect>::value, "");
+    static_assert(std::is_same<RetR, Expect>::value, "");
+    static_assert(std::is_same<RetR2, Expect>::value, "");
+
+    Expect exp = ret(100); // the input value is ignored. dummy is returned.
+    Expect exp2 = ret(101, 102);
+    Expect exp_r = ret_r(100);
+    Expect exp_r2 = ret_r(101, 102);
+
+    assert(exp == 42);
+    assert(exp2 == 42);
+    assert(exp_r == 42);
+    assert(exp_r2 == 42);
+
+    if ((std::is_reference<Expect>::value)) {
+        assert(&exp == &dummy);
+        assert(&exp2 == &dummy);
+        assert(&exp_r == &dummy);
+        assert(&exp_r2 == &dummy);
+    }
+    // Check that the call operator SFINAE's away when too few arguments
+    // are provided but is well-formed otherwise.
+    {
+        static_assert(!CheckCall<Bind>(), "");
+        static_assert(CheckCall<Bind, int>(), "");
+        static_assert(CheckCall<Bind, int, int>(), "");
+        static_assert(!CheckCall<BindR>(), "");
+        static_assert(CheckCall<BindR, int>(), "");
+        static_assert(CheckCall<BindR, int, int>(), "");
+    }
+}
+
+
+// Test but with an explicit return type which differs from the real one.
+template <class Expect, class Fn>
+void do_test_r(Fn* func) {
+    using namespace std::placeholders;
+    auto ret = std::bind<Expect>(func, _1);
+    using Bind = decltype(ret);
+    using Ret = decltype(ret(42));
+    using Ret2 = decltype(ret(42, 43)); // Test that the extra argument is discarded.
+    static_assert(std::is_same<Ret, Expect>::value, "");
+    static_assert(std::is_same<Ret2, Expect>::value, "");
+    Expect exp = ret(100); // the input value is ignored
+    Expect exp2 = ret(101, 102);
+    assert(exp == 42);
+    assert(exp2 == 42);
+    // Check that the call operator SFINAE's away when too few arguments
+    // are provided but is well-formed otherwise.
+    {
+        static_assert(!CheckCall<Bind>(), "");
+        static_assert(CheckCall<Bind, int>(), "");
+        static_assert(CheckCall<Bind, int, int>(), "");
+    }
+}
+
+int main()
+{
+    do_test<int>(return_value);
+    do_test<int&>(return_lvalue);
+    do_test<const int&>(return_const_lvalue);
+    do_test<int&&>(return_rvalue);
+    do_test<const int&&>(return_const_rvalue);
+
+    do_test_r<long>(return_value);
+    do_test_r<long>(return_lvalue);
+    do_test_r<long>(return_const_lvalue);
+    do_test_r<long>(return_rvalue);
+    do_test_r<long>(return_const_rvalue);
+
+}
diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_function_object.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_function_object.pass.cpp
index 4577d0bf4d54..a0c686de77ba 100644
--- a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_function_object.pass.cpp
+++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_function_object.pass.cpp
@@ -23,7 +23,7 @@
 struct DummyUnaryFunction
 {
     template <typename S>
-    int operator()(S const & s) const { return 0; }
+    int operator()(S const &) const { return 0; }
 };
 
 struct BadUnaryFunction
@@ -39,7 +39,7 @@ struct BadUnaryFunction
     }
 };
 
-int main(int argc, char* argv[])
+int main()
 {
     // Check that BadUnaryFunction::operator()(S const &) is not
     // instantiated when checking if BadUnaryFunction is a nested bind
diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_lvalue.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_lvalue.pass.cpp
index f69afbf57667..dbbd184c7833 100644
--- a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_lvalue.pass.cpp
+++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_lvalue.pass.cpp
@@ -286,4 +286,5 @@ int main()
     test_void_1();
     test_int_1();
     test_void_2();
+    test3();
 }
diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.place/placeholders.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.place/placeholders.pass.cpp
index 246186040c56..68986ac1aeb3 100644
--- a/test/std/utilities/function.objects/bind/func.bind/func.bind.place/placeholders.pass.cpp
+++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.place/placeholders.pass.cpp
@@ -10,10 +10,14 @@
 // <functional>
 
 // placeholders
+// The placeholders are constexpr in C++17 and beyond.
+// libc++ provides constexpr placeholders in C++11 and beyond.
 
 #include <functional>
 #include <type_traits>
 
+#include "test_macros.h"
+
 template <class T>
 void
 test(const T& t)
@@ -28,6 +32,30 @@ test(const T& t)
     static_assert(std::is_nothrow_move_constructible<T>::value, "");
 }
 
+#if TEST_STD_VER >= 11
+constexpr decltype(std::placeholders::_1)  default1{};
+constexpr decltype(std::placeholders::_2)  default2{};
+constexpr decltype(std::placeholders::_3)  default3{};
+constexpr decltype(std::placeholders::_4)  default4{};
+constexpr decltype(std::placeholders::_5)  default5{};
+constexpr decltype(std::placeholders::_6)  default6{};
+constexpr decltype(std::placeholders::_7)  default7{};
+constexpr decltype(std::placeholders::_8)  default8{};
+constexpr decltype(std::placeholders::_9)  default9{};
+constexpr decltype(std::placeholders::_10) default10{};
+
+constexpr decltype(std::placeholders::_1)  cp1 = std::placeholders::_1;
+constexpr decltype(std::placeholders::_2)  cp2 = std::placeholders::_2;
+constexpr decltype(std::placeholders::_3)  cp3 = std::placeholders::_3;
+constexpr decltype(std::placeholders::_4)  cp4 = std::placeholders::_4;
+constexpr decltype(std::placeholders::_5)  cp5 = std::placeholders::_5;
+constexpr decltype(std::placeholders::_6)  cp6 = std::placeholders::_6;
+constexpr decltype(std::placeholders::_7)  cp7 = std::placeholders::_7;
+constexpr decltype(std::placeholders::_8)  cp8 = std::placeholders::_8;
+constexpr decltype(std::placeholders::_9)  cp9 = std::placeholders::_9;
+constexpr decltype(std::placeholders::_10) cp10 = std::placeholders::_10;
+#endif // TEST_STD_VER >= 11
+
 int main()
 {
     test(std::placeholders::_1);
diff --git a/test/std/utilities/function.objects/bitwise.operations/bit_not.pass.cpp b/test/std/utilities/function.objects/bitwise.operations/bit_not.pass.cpp
index 48800a366a81..d5788986dd25 100644
--- a/test/std/utilities/function.objects/bitwise.operations/bit_not.pass.cpp
+++ b/test/std/utilities/function.objects/bitwise.operations/bit_not.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <functional>
 
 // bit_not
@@ -17,7 +18,6 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     typedef std::bit_not<int> F;
     const F f = F();
     static_assert((std::is_same<F::argument_type, int>::value), "" );
@@ -43,5 +43,4 @@ int main()
 
     constexpr int bar = std::bit_not<> () (0xEA95) & 0xFFFF;
     static_assert ( bar == 0x156A, "" );
-#endif
 }
diff --git a/test/std/utilities/function.objects/bitwise.operations/transparent.pass.cpp b/test/std/utilities/function.objects/bitwise.operations/transparent.pass.cpp
index 9f8e15dd55fe..db7168c44f8b 100644
--- a/test/std/utilities/function.objects/bitwise.operations/transparent.pass.cpp
+++ b/test/std/utilities/function.objects/bitwise.operations/transparent.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 #include <functional>
 #include <string>
 
@@ -23,8 +24,6 @@ public:
 
 
 int main () {
-#if _LIBCPP_STD_VER > 11
-
     static_assert ( !is_transparent<std::bit_and<int>>::value, "" );
     static_assert ( !is_transparent<std::bit_and<std::string>>::value, "" );
     static_assert (  is_transparent<std::bit_and<void>>::value, "" );
@@ -44,8 +43,6 @@ int main () {
     static_assert ( !is_transparent<std::bit_not<std::string>>::value, "" );
     static_assert (  is_transparent<std::bit_not<void>>::value, "" );
     static_assert (  is_transparent<std::bit_not<>>::value, "" );
-    
-#endif
 
     return 0;
-    }
+}
diff --git a/test/std/utilities/function.objects/comparisons/equal_to.pass.cpp b/test/std/utilities/function.objects/comparisons/equal_to.pass.cpp
index 60415ec75d60..d4d99756fecc 100644
--- a/test/std/utilities/function.objects/comparisons/equal_to.pass.cpp
+++ b/test/std/utilities/function.objects/comparisons/equal_to.pass.cpp
@@ -15,6 +15,8 @@
 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
     typedef std::equal_to<int> F;
@@ -24,7 +26,7 @@ int main()
     static_assert((std::is_same<bool, F::result_type>::value), "" );
     assert(f(36, 36));
     assert(!f(36, 6));
-#if _LIBCPP_STD_VER > 11
+#if TEST_STD_VER > 11
     typedef std::equal_to<> F2;
     const F2 f2 = F2();
     assert(f2(36, 36));
diff --git a/test/std/utilities/function.objects/comparisons/greater.pass.cpp b/test/std/utilities/function.objects/comparisons/greater.pass.cpp
index 164f09aa605c..50bdcceee1c9 100644
--- a/test/std/utilities/function.objects/comparisons/greater.pass.cpp
+++ b/test/std/utilities/function.objects/comparisons/greater.pass.cpp
@@ -15,6 +15,9 @@
 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
+#include "pointer_comparison_test_helper.hpp"
+
 int main()
 {
     typedef std::greater<int> F;
@@ -25,7 +28,12 @@ int main()
     assert(!f(36, 36));
     assert(f(36, 6));
     assert(!f(6, 36));
-#if _LIBCPP_STD_VER > 11
+    {
+        // test total ordering of int* for greater<int*> and
+        // greater<void>.
+        do_pointer_comparison_test<int, std::greater>();
+    }
+#if TEST_STD_VER > 11
     typedef std::greater<> F2;
     const F2 f2 = F2();
     assert(!f2(36, 36));
diff --git a/test/std/utilities/function.objects/comparisons/greater_equal.pass.cpp b/test/std/utilities/function.objects/comparisons/greater_equal.pass.cpp
index e89c14e24625..0aacb81e9cb4 100644
--- a/test/std/utilities/function.objects/comparisons/greater_equal.pass.cpp
+++ b/test/std/utilities/function.objects/comparisons/greater_equal.pass.cpp
@@ -15,6 +15,9 @@
 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
+#include "pointer_comparison_test_helper.hpp"
+
 int main()
 {
     typedef std::greater_equal<int> F;
@@ -25,7 +28,12 @@ int main()
     assert(f(36, 36));
     assert(f(36, 6));
     assert(!f(6, 36));
-#if _LIBCPP_STD_VER > 11
+    {
+        // test total ordering of int* for greater_equal<int*> and
+        // greater_equal<void>.
+        do_pointer_comparison_test<int, std::greater_equal>();
+    }
+#if TEST_STD_VER > 11
     typedef std::greater_equal<> F2;
     const F2 f2 = F2();
     assert(f2(36, 36));
diff --git a/test/std/utilities/function.objects/comparisons/less.pass.cpp b/test/std/utilities/function.objects/comparisons/less.pass.cpp
index 74fe166a0cd9..191d58d6e544 100644
--- a/test/std/utilities/function.objects/comparisons/less.pass.cpp
+++ b/test/std/utilities/function.objects/comparisons/less.pass.cpp
@@ -15,6 +15,9 @@
 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
+#include "pointer_comparison_test_helper.hpp"
+
 int main()
 {
     typedef std::less<int> F;
@@ -25,7 +28,11 @@ int main()
     assert(!f(36, 36));
     assert(!f(36, 6));
     assert(f(6, 36));
-#if _LIBCPP_STD_VER > 11
+    {
+        // test total ordering of int* for less<int*> and less<void>.
+        do_pointer_comparison_test<int, std::less>();
+    }
+#if TEST_STD_VER > 11
     typedef std::less<> F2;
     const F2 f2 = F2();
     assert(!f2(36, 36));
diff --git a/test/std/utilities/function.objects/comparisons/less_equal.pass.cpp b/test/std/utilities/function.objects/comparisons/less_equal.pass.cpp
index e6ba1f7f8a21..a6aca5d19569 100644
--- a/test/std/utilities/function.objects/comparisons/less_equal.pass.cpp
+++ b/test/std/utilities/function.objects/comparisons/less_equal.pass.cpp
@@ -15,6 +15,9 @@
 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
+#include "pointer_comparison_test_helper.hpp"
+
 int main()
 {
     typedef std::less_equal<int> F;
@@ -25,7 +28,12 @@ int main()
     assert(f(36, 36));
     assert(!f(36, 6));
     assert(f(6, 36));
-#if _LIBCPP_STD_VER > 11
+    {
+        // test total ordering of int* for less_equal<int*> and
+        // less_equal<void>.
+        do_pointer_comparison_test<int, std::less_equal>();
+    }
+#if TEST_STD_VER > 11
     typedef std::less_equal<> F2;
     const F2 f2 = F2();
     assert( f2(36, 36));
diff --git a/test/std/utilities/function.objects/comparisons/not_equal_to.pass.cpp b/test/std/utilities/function.objects/comparisons/not_equal_to.pass.cpp
index 3e710b3e0c70..777c25d520a9 100644
--- a/test/std/utilities/function.objects/comparisons/not_equal_to.pass.cpp
+++ b/test/std/utilities/function.objects/comparisons/not_equal_to.pass.cpp
@@ -15,6 +15,8 @@
 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
     typedef std::not_equal_to<int> F;
@@ -24,7 +26,7 @@ int main()
     static_assert((std::is_same<bool, F::result_type>::value), "" );
     assert(!f(36, 36));
     assert(f(36, 6));
-#if _LIBCPP_STD_VER > 11
+#if TEST_STD_VER > 11
     typedef std::not_equal_to<> F2;
     const F2 f2 = F2();
     assert(!f2(36, 36));
diff --git a/test/std/utilities/function.objects/comparisons/pointer_comparison_test_helper.hpp b/test/std/utilities/function.objects/comparisons/pointer_comparison_test_helper.hpp
new file mode 100644
index 000000000000..66d783a6e357
--- /dev/null
+++ b/test/std/utilities/function.objects/comparisons/pointer_comparison_test_helper.hpp
@@ -0,0 +1,39 @@
+#ifndef POINTER_COMPARISON_TEST_HELPER_HPP
+#define POINTER_COMPARISON_TEST_HELPER_HPP
+
+#include <vector>
+#include <memory>
+#include <cstdint>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <class T, template<class> class CompareTemplate>
+void do_pointer_comparison_test() {
+    typedef CompareTemplate<T*> Compare;
+    typedef CompareTemplate<std::uintptr_t> UIntCompare;
+#if TEST_STD_VER > 11
+    typedef CompareTemplate<void> VoidCompare;
+#else
+    typedef Compare VoidCompare;
+#endif
+    std::vector<std::shared_ptr<T> > pointers;
+    const std::size_t test_size = 100;
+    for (int i=0; i < test_size; ++i)
+        pointers.push_back(std::shared_ptr<T>(new T()));
+    Compare comp;
+    UIntCompare ucomp;
+    VoidCompare vcomp;
+    for (int i=0; i < test_size; ++i) {
+        for (int j=0; j < test_size; ++j) {
+            T* lhs = pointers[i].get();
+            T* rhs = pointers[j].get();
+            std::uintptr_t lhs_uint = reinterpret_cast<std::uintptr_t>(lhs);
+            std::uintptr_t rhs_uint = reinterpret_cast<std::uintptr_t>(rhs);
+            assert(comp(lhs, rhs) == ucomp(lhs_uint, rhs_uint));
+            assert(vcomp(lhs, rhs) == ucomp(lhs_uint, rhs_uint));
+        }
+    }
+}
+
+#endif // POINTER_COMPARISON_TEST_HELPER_HPP
diff --git a/test/std/utilities/function.objects/comparisons/transparent.pass.cpp b/test/std/utilities/function.objects/comparisons/transparent.pass.cpp
index 41ce4bcae65f..f353fe7a72a6 100644
--- a/test/std/utilities/function.objects/comparisons/transparent.pass.cpp
+++ b/test/std/utilities/function.objects/comparisons/transparent.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 #include <functional>
 #include <string>
 
@@ -22,9 +23,8 @@ public:
 };
 
 
-int main () {
-#if _LIBCPP_STD_VER > 11
-
+int main ()
+{
     static_assert ( !is_transparent<std::less<int>>::value, "" );
     static_assert ( !is_transparent<std::less<std::string>>::value, "" );
     static_assert (  is_transparent<std::less<void>>::value, "" );
@@ -55,7 +55,5 @@ int main () {
     static_assert (  is_transparent<std::greater_equal<void>>::value, "" );
     static_assert (  is_transparent<std::greater_equal<>>::value, "" );
 
-#endif
-
     return 0;
-    }
+}
diff --git a/test/std/utilities/function.objects/func.invoke/invoke.pass.cpp b/test/std/utilities/function.objects/func.invoke/invoke.pass.cpp
index 97b0b4d158a0..d1ae6b7809ce 100644
--- a/test/std/utilities/function.objects/func.invoke/invoke.pass.cpp
+++ b/test/std/utilities/function.objects/func.invoke/invoke.pass.cpp
@@ -174,6 +174,32 @@ void bullet_one_two_tests() {
     }
     {
         TestClass cl_obj(42);
+        std::reference_wrapper<TestClass> cl(cl_obj);
+        test_b12<int&(NonCopyable&&) &, int&>(cl);
+        test_b12<int const&(NonCopyable&&) const &, int const&>(cl);
+        test_b12<int volatile&(NonCopyable&&) volatile &, int volatile&>(cl);
+        test_b12<int const volatile&(NonCopyable&&) const volatile &, int const volatile&>(cl);
+
+        test_b12<int&(NonCopyable&&) &, int&>(std::move(cl));
+        test_b12<int const&(NonCopyable&&) const &, int const&>(std::move(cl));
+        test_b12<int volatile&(NonCopyable&&) volatile &, int volatile&>(std::move(cl));
+        test_b12<int const volatile&(NonCopyable&&) const volatile &, int const volatile&>(std::move(cl));
+    }
+    {
+        DerivedFromTestClass cl_obj(42);
+        std::reference_wrapper<DerivedFromTestClass> cl(cl_obj);
+        test_b12<int&(NonCopyable&&) &, int&>(cl);
+        test_b12<int const&(NonCopyable&&) const &, int const&>(cl);
+        test_b12<int volatile&(NonCopyable&&) volatile &, int volatile&>(cl);
+        test_b12<int const volatile&(NonCopyable&&) const volatile &, int const volatile&>(cl);
+
+        test_b12<int&(NonCopyable&&) &, int&>(std::move(cl));
+        test_b12<int const&(NonCopyable&&) const &, int const&>(std::move(cl));
+        test_b12<int volatile&(NonCopyable&&) volatile &, int volatile&>(std::move(cl));
+        test_b12<int const volatile&(NonCopyable&&) const volatile &, int const volatile&>(std::move(cl));
+    }
+    {
+        TestClass cl_obj(42);
         TestClass *cl = &cl_obj;
         test_b12<int&(NonCopyable&&) &, int&>(cl);
         test_b12<int const&(NonCopyable&&) const &, int const&>(cl);
@@ -219,6 +245,22 @@ void bullet_three_four_tests() {
     }
     {
         typedef TestClass Fn;
+        Fn cl(42);
+        test_b34<int&>(std::reference_wrapper<Fn>(cl));
+        test_b34<int const&>(std::reference_wrapper<Fn const>(cl));
+        test_b34<int volatile&>(std::reference_wrapper<Fn volatile>(cl));
+        test_b34<int const volatile&>(std::reference_wrapper<Fn const volatile>(cl));
+    }
+    {
+        typedef DerivedFromTestClass Fn;
+        Fn cl(42);
+        test_b34<int&>(std::reference_wrapper<Fn>(cl));
+        test_b34<int const&>(std::reference_wrapper<Fn const>(cl));
+        test_b34<int volatile&>(std::reference_wrapper<Fn volatile>(cl));
+        test_b34<int const volatile&>(std::reference_wrapper<Fn const volatile>(cl));
+    }
+    {
+        typedef TestClass Fn;
         Fn cl_obj(42);
         Fn* cl = &cl_obj;
         test_b34<int&>(cl);
@@ -262,8 +304,46 @@ void bullet_five_tests() {
     }
 }
 
+struct CopyThrows {
+  CopyThrows() {}
+  CopyThrows(CopyThrows const&) {}
+  CopyThrows(CopyThrows&&) noexcept {}
+};
+
+struct NoThrowCallable {
+  void operator()() noexcept {}
+  void operator()(CopyThrows) noexcept {}
+};
+
+struct ThrowsCallable {
+  void operator()() {}
+};
+
+struct MemberObj {
+  int x;
+};
+
+void noexcept_test() {
+    {
+        NoThrowCallable obj; ((void)obj); // suppress unused warning
+        CopyThrows arg; ((void)arg); // suppress unused warning
+        static_assert(noexcept(std::invoke(obj)), "");
+        static_assert(!noexcept(std::invoke(obj, arg)), "");
+        static_assert(noexcept(std::invoke(obj, std::move(arg))), "");
+    }
+    {
+        ThrowsCallable obj; ((void)obj); // suppress unused warning
+        static_assert(!noexcept(std::invoke(obj)), "");
+    }
+    {
+        MemberObj obj{42}; ((void)obj); // suppress unused warning.
+        static_assert(noexcept(std::invoke(&MemberObj::x, obj)), "");
+    }
+}
+
 int main() {
     bullet_one_two_tests();
     bullet_three_four_tests();
     bullet_five_tests();
+    noexcept_test();
 }
diff --git a/test/std/utilities/function.objects/func.memfn/member_function.pass.cpp b/test/std/utilities/function.objects/func.memfn/member_function.pass.cpp
index f371223ee84c..465e001c3deb 100644
--- a/test/std/utilities/function.objects/func.memfn/member_function.pass.cpp
+++ b/test/std/utilities/function.objects/func.memfn/member_function.pass.cpp
@@ -15,6 +15,8 @@
 #include <functional>
 #include <cassert>
 
+#include "test_macros.h"
+
 struct A
 {
     char test0() {return 'a';}
@@ -69,7 +71,7 @@ int main()
     test0(std::mem_fn(&A::test0));
     test1(std::mem_fn(&A::test1));
     test2(std::mem_fn(&A::test2));
-#if __has_feature(cxx_noexcept)
+#if TEST_STD_VER >= 11
     static_assert((noexcept(std::mem_fn(&A::test0))), ""); // LWG#2489
 #endif
 }
diff --git a/test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp b/test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp
new file mode 100644
index 000000000000..c12fa7920974
--- /dev/null
+++ b/test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp
@@ -0,0 +1,589 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11, c++14
+
+// template <class F> unspecified not_fn(F&& f);
+
+#include <functional>
+#include <type_traits>
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+#include "type_id.h"
+
+
+///////////////////////////////////////////////////////////////////////////////
+//                       CALLABLE TEST TYPES
+///////////////////////////////////////////////////////////////////////////////
+
+bool returns_true() { return true; }
+
+template <class Ret = bool>
+struct MoveOnlyCallable {
+  MoveOnlyCallable(MoveOnlyCallable const&) = delete;
+  MoveOnlyCallable(MoveOnlyCallable&& other)
+      : value(other.value)
+  { other.value = !other.value; }
+
+  template <class ...Args>
+  Ret operator()(Args&&...) { return Ret{value}; }
+
+  explicit MoveOnlyCallable(bool x) : value(x) {}
+  Ret value;
+};
+
+template <class Ret = bool>
+struct CopyCallable {
+  CopyCallable(CopyCallable const& other)
+      : value(other.value) {}
+
+  CopyCallable(CopyCallable&& other)
+      : value(other.value) { other.value = !other.value; }
+
+  template <class ...Args>
+  Ret operator()(Args&&...) { return Ret{value}; }
+
+  explicit CopyCallable(bool x) : value(x)  {}
+  Ret value;
+};
+
+
+template <class Ret = bool>
+struct ConstCallable {
+  ConstCallable(ConstCallable const& other)
+      : value(other.value) {}
+
+  ConstCallable(ConstCallable&& other)
+      : value(other.value) { other.value = !other.value; }
+
+  template <class ...Args>
+  Ret operator()(Args&&...) const { return Ret{value}; }
+
+  explicit ConstCallable(bool x) : value(x)  {}
+  Ret value;
+};
+
+
+
+template <class Ret = bool>
+struct NoExceptCallable {
+  NoExceptCallable(NoExceptCallable const& other)
+      : value(other.value) {}
+
+  template <class ...Args>
+  Ret operator()(Args&&...) noexcept { return Ret{value}; }
+
+  template <class ...Args>
+  Ret operator()(Args&&...) const noexcept { return Ret{value}; }
+
+  explicit NoExceptCallable(bool x) : value(x)  {}
+  Ret value;
+};
+
+struct CopyAssignableWrapper {
+  CopyAssignableWrapper(CopyAssignableWrapper const&) = default;
+  CopyAssignableWrapper(CopyAssignableWrapper&&) = default;
+  CopyAssignableWrapper& operator=(CopyAssignableWrapper const&) = default;
+  CopyAssignableWrapper& operator=(CopyAssignableWrapper &&) = default;
+
+  template <class ...Args>
+  bool operator()(Args&&...) { return value; }
+
+  explicit CopyAssignableWrapper(bool x) : value(x) {}
+  bool value;
+};
+
+
+struct MoveAssignableWrapper {
+  MoveAssignableWrapper(MoveAssignableWrapper const&) = delete;
+  MoveAssignableWrapper(MoveAssignableWrapper&&) = default;
+  MoveAssignableWrapper& operator=(MoveAssignableWrapper const&) = delete;
+  MoveAssignableWrapper& operator=(MoveAssignableWrapper &&) = default;
+
+  template <class ...Args>
+  bool operator()(Args&&...) { return value; }
+
+  explicit MoveAssignableWrapper(bool x) : value(x) {}
+  bool value;
+};
+
+struct MemFunCallable {
+  explicit MemFunCallable(bool x) : value(x) {}
+
+  bool return_value() const { return value; }
+  bool return_value_nc() { return value; }
+  bool value;
+};
+
+enum CallType : unsigned {
+  CT_None,
+  CT_NonConst = 1,
+  CT_Const = 2,
+  CT_LValue = 4,
+  CT_RValue = 8
+};
+
+inline constexpr CallType operator|(CallType LHS, CallType RHS) {
+    return static_cast<CallType>(static_cast<unsigned>(LHS) | static_cast<unsigned>(RHS));
+}
+
+struct ForwardingCallObject {
+
+  template <class ...Args>
+  bool operator()(Args&&... args) & {
+      set_call<Args&&...>(CT_NonConst | CT_LValue);
+      return true;
+  }
+
+  template <class ...Args>
+  bool operator()(Args&&... args) const & {
+      set_call<Args&&...>(CT_Const | CT_LValue);
+      return true;
+  }
+
+  // Don't allow the call operator to be invoked as an rvalue.
+  template <class ...Args>
+  bool operator()(Args&&... args) && {
+      set_call<Args&&...>(CT_NonConst | CT_RValue);
+      return true;
+  }
+
+  template <class ...Args>
+  bool operator()(Args&&... args) const && {
+      set_call<Args&&...>(CT_Const | CT_RValue);
+      return true;
+  }
+
+  template <class ...Args>
+  static void set_call(CallType type) {
+      assert(last_call_type == CT_None);
+      assert(last_call_args == nullptr);
+      last_call_type = type;
+      last_call_args = &makeArgumentID<Args...>();
+  }
+
+  template <class ...Args>
+  static bool check_call(CallType type) {
+      bool result =
+           last_call_type == type
+        && last_call_args
+        && *last_call_args == makeArgumentID<Args...>();
+      last_call_type = CT_None;
+      last_call_args = nullptr;
+      return result;
+  }
+
+  static CallType      last_call_type;
+  static TypeID const* last_call_args;
+};
+
+CallType ForwardingCallObject::last_call_type = CT_None;
+TypeID const* ForwardingCallObject::last_call_args = nullptr;
+
+
+
+///////////////////////////////////////////////////////////////////////////////
+//                        BOOL TEST TYPES
+///////////////////////////////////////////////////////////////////////////////
+
+struct EvilBool {
+  static int bang_called;
+
+  EvilBool(EvilBool const&) = default;
+  EvilBool(EvilBool&&) = default;
+
+  friend EvilBool operator!(EvilBool const& other) {
+    ++bang_called;
+    return EvilBool{!other.value};
+  }
+
+private:
+  friend struct MoveOnlyCallable<EvilBool>;
+  friend struct CopyCallable<EvilBool>;
+  friend struct NoExceptCallable<EvilBool>;
+
+  explicit EvilBool(bool x) : value(x) {}
+  EvilBool& operator=(EvilBool const& other) = default;
+
+public:
+  bool value;
+};
+
+int EvilBool::bang_called = 0;
+
+struct ExplicitBool {
+  ExplicitBool(ExplicitBool const&) = default;
+  ExplicitBool(ExplicitBool&&) = default;
+
+  explicit operator bool() const { return value; }
+
+private:
+  friend struct MoveOnlyCallable<ExplicitBool>;
+  friend struct CopyCallable<ExplicitBool>;
+
+  explicit ExplicitBool(bool x) : value(x) {}
+  ExplicitBool& operator=(bool x) {
+      value = x;
+      return *this;
+  }
+
+  bool value;
+};
+
+
+struct NoExceptEvilBool {
+  NoExceptEvilBool(NoExceptEvilBool const&) = default;
+  NoExceptEvilBool(NoExceptEvilBool&&) = default;
+  NoExceptEvilBool& operator=(NoExceptEvilBool const& other) = default;
+
+  explicit NoExceptEvilBool(bool x) : value(x) {}
+
+  friend NoExceptEvilBool operator!(NoExceptEvilBool const& other) noexcept {
+    return NoExceptEvilBool{!other.value};
+  }
+
+  bool value;
+};
+
+
+
+void constructor_tests()
+{
+    {
+        using T = MoveOnlyCallable<bool>;
+        T value(true);
+        using RetT = decltype(std::not_fn(std::move(value)));
+        static_assert(std::is_move_constructible<RetT>::value, "");
+        static_assert(!std::is_copy_constructible<RetT>::value, "");
+        static_assert(!std::is_move_assignable<RetT>::value, "");
+        static_assert(!std::is_copy_assignable<RetT>::value, "");
+        auto ret = std::not_fn(std::move(value));
+        // test it was moved from
+        assert(value.value == false);
+        // test that ret() negates the original value 'true'
+        assert(ret() == false);
+        assert(ret(0, 0.0, "blah") == false);
+        // Move ret and test that it was moved from and that ret2 got the
+        // original value.
+        auto ret2 = std::move(ret);
+        assert(ret() == true);
+        assert(ret2() == false);
+        assert(ret2(42) == false);
+    }
+    {
+        using T = CopyCallable<bool>;
+        T value(false);
+        using RetT = decltype(std::not_fn(value));
+        static_assert(std::is_move_constructible<RetT>::value, "");
+        static_assert(std::is_copy_constructible<RetT>::value, "");
+        static_assert(!std::is_move_assignable<RetT>::value, "");
+        static_assert(!std::is_copy_assignable<RetT>::value, "");
+        auto ret = std::not_fn(value);
+        // test that value is unchanged (copied not moved)
+        assert(value.value == false);
+        // test 'ret' has the original value
+        assert(ret() == true);
+        assert(ret(42, 100) == true);
+        // move from 'ret' and check that 'ret2' has the original value.
+        auto ret2 = std::move(ret);
+        assert(ret() == false);
+        assert(ret2() == true);
+        assert(ret2("abc") == true);
+    }
+    {
+        using T = CopyAssignableWrapper;
+        T value(true);
+        T value2(false);
+        using RetT = decltype(std::not_fn(value));
+        static_assert(std::is_move_constructible<RetT>::value, "");
+        static_assert(std::is_copy_constructible<RetT>::value, "");
+        static_assert(std::is_move_assignable<RetT>::value, "");
+        static_assert(std::is_copy_assignable<RetT>::value, "");
+        auto ret = std::not_fn(value);
+        assert(ret() == false);
+        auto ret2 = std::not_fn(value2);
+        assert(ret2() == true);
+        ret = ret2;
+        assert(ret() == true);
+        assert(ret2() == true);
+    }
+    {
+        using T = MoveAssignableWrapper;
+        T value(true);
+        T value2(false);
+        using RetT = decltype(std::not_fn(std::move(value)));
+        static_assert(std::is_move_constructible<RetT>::value, "");
+        static_assert(!std::is_copy_constructible<RetT>::value, "");
+        static_assert(std::is_move_assignable<RetT>::value, "");
+        static_assert(!std::is_copy_assignable<RetT>::value, "");
+        auto ret = std::not_fn(std::move(value));
+        assert(ret() == false);
+        auto ret2 = std::not_fn(std::move(value2));
+        assert(ret2() == true);
+        ret = std::move(ret2);
+        assert(ret() == true);
+    }
+}
+
+void return_type_tests()
+{
+    using std::is_same;
+    {
+        using T = CopyCallable<bool>;
+        auto ret = std::not_fn(T{false});
+        static_assert(is_same<decltype(ret()), bool>::value, "");
+        static_assert(is_same<decltype(ret("abc")), bool>::value, "");
+        assert(ret() == true);
+    }
+    {
+        using T = CopyCallable<ExplicitBool>;
+        auto ret = std::not_fn(T{true});
+        static_assert(is_same<decltype(ret()), bool>::value, "");
+        static_assert(is_same<decltype(ret(std::string("abc"))), bool>::value, "");
+        assert(ret() == false);
+    }
+    {
+        using T = CopyCallable<EvilBool>;
+        auto ret = std::not_fn(T{false});
+        static_assert(is_same<decltype(ret()), EvilBool>::value, "");
+        EvilBool::bang_called = 0;
+        auto value_ret = ret();
+        assert(EvilBool::bang_called == 1);
+        assert(value_ret.value == true);
+        ret();
+        assert(EvilBool::bang_called == 2);
+    }
+}
+
+// Other tests only test using objects with call operators. Test various
+// other callable types here.
+void other_callable_types_test()
+{
+    { // test with function pointer
+        auto ret = std::not_fn(returns_true);
+        assert(ret() == false);
+    }
+    { // test with lambda
+        auto returns_value = [](bool value) { return value; };
+        auto ret = std::not_fn(returns_value);
+        assert(ret(true) == false);
+        assert(ret(false) == true);
+    }
+    { // test with pointer to member function
+        MemFunCallable mt(true);
+        const MemFunCallable mf(false);
+        auto ret = std::not_fn(&MemFunCallable::return_value);
+        assert(ret(mt) == false);
+        assert(ret(mf) == true);
+        assert(ret(&mt) == false);
+        assert(ret(&mf) == true);
+    }
+    { // test with pointer to member function
+        MemFunCallable mt(true);
+        MemFunCallable mf(false);
+        auto ret = std::not_fn(&MemFunCallable::return_value_nc);
+        assert(ret(mt) == false);
+        assert(ret(mf) == true);
+        assert(ret(&mt) == false);
+        assert(ret(&mf) == true);
+    }
+    { // test with pointer to member data
+        MemFunCallable mt(true);
+        const MemFunCallable mf(false);
+        auto ret = std::not_fn(&MemFunCallable::value);
+        assert(ret(mt) == false);
+        assert(ret(mf) == true);
+        assert(ret(&mt) == false);
+        assert(ret(&mf) == true);
+    }
+}
+
+void throws_in_constructor_test()
+{
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    struct ThrowsOnCopy {
+      ThrowsOnCopy(ThrowsOnCopy const&) {
+        throw 42;
+      }
+      ThrowsOnCopy() = default;
+      bool operator()() const { assert(false); }
+    };
+    {
+        ThrowsOnCopy cp;
+        try {
+            std::not_fn(cp);
+            assert(false);
+        } catch (int const& value) {
+            assert(value == 42);
+        }
+    }
+#endif
+}
+
+void call_operator_sfinae_test() {
+    { // wrong number of arguments
+        using T = decltype(std::not_fn(returns_true));
+        static_assert(std::is_callable<T()>::value, ""); // callable only with no args
+        static_assert(!std::is_callable<T(bool)>::value, "");
+    }
+    { // violates const correctness (member function pointer)
+        using T = decltype(std::not_fn(&MemFunCallable::return_value_nc));
+        static_assert(std::is_callable<T(MemFunCallable&)>::value, "");
+        static_assert(!std::is_callable<T(const MemFunCallable&)>::value, "");
+    }
+    { // violates const correctness (call object)
+        using Obj = CopyCallable<bool>;
+        using NCT = decltype(std::not_fn(Obj{true}));
+        using CT = const NCT;
+        static_assert(std::is_callable<NCT()>::value, "");
+        static_assert(!std::is_callable<CT()>::value, "");
+    }
+    { // returns bad type with no operator!
+        auto fn = [](auto x) { return x; };
+        using T = decltype(std::not_fn(fn));
+        static_assert(std::is_callable<T(bool)>::value, "");
+        static_assert(!std::is_callable<T(std::string)>::value, "");
+    }
+}
+
+void call_operator_forwarding_test()
+{
+    using Fn = ForwardingCallObject;
+    auto obj = std::not_fn(Fn{});
+    const auto& c_obj = obj;
+    { // test zero args
+        obj();
+        assert(Fn::check_call<>(CT_NonConst | CT_LValue));
+        std::move(obj)();
+        assert(Fn::check_call<>(CT_NonConst | CT_RValue));
+        c_obj();
+        assert(Fn::check_call<>(CT_Const | CT_LValue));
+        std::move(c_obj)();
+        assert(Fn::check_call<>(CT_Const | CT_RValue));
+    }
+    { // test value categories
+        int x = 42;
+        const int cx = 42;
+        obj(x);
+        assert(Fn::check_call<int&>(CT_NonConst | CT_LValue));
+        obj(cx);
+        assert(Fn::check_call<const int&>(CT_NonConst | CT_LValue));
+        obj(std::move(x));
+        assert(Fn::check_call<int&&>(CT_NonConst | CT_LValue));
+        obj(std::move(cx));
+        assert(Fn::check_call<const int&&>(CT_NonConst | CT_LValue));
+        obj(42);
+        assert(Fn::check_call<int&&>(CT_NonConst | CT_LValue));
+    }
+    { // test value categories - rvalue
+        int x = 42;
+        const int cx = 42;
+        std::move(obj)(x);
+        assert(Fn::check_call<int&>(CT_NonConst | CT_RValue));
+        std::move(obj)(cx);
+        assert(Fn::check_call<const int&>(CT_NonConst | CT_RValue));
+        std::move(obj)(std::move(x));
+        assert(Fn::check_call<int&&>(CT_NonConst | CT_RValue));
+        std::move(obj)(std::move(cx));
+        assert(Fn::check_call<const int&&>(CT_NonConst | CT_RValue));
+        std::move(obj)(42);
+        assert(Fn::check_call<int&&>(CT_NonConst | CT_RValue));
+    }
+    { // test value categories - const call
+        int x = 42;
+        const int cx = 42;
+        c_obj(x);
+        assert(Fn::check_call<int&>(CT_Const | CT_LValue));
+        c_obj(cx);
+        assert(Fn::check_call<const int&>(CT_Const | CT_LValue));
+        c_obj(std::move(x));
+        assert(Fn::check_call<int&&>(CT_Const | CT_LValue));
+        c_obj(std::move(cx));
+        assert(Fn::check_call<const int&&>(CT_Const | CT_LValue));
+        c_obj(42);
+        assert(Fn::check_call<int&&>(CT_Const | CT_LValue));
+    }
+    { // test value categories - const call rvalue
+        int x = 42;
+        const int cx = 42;
+        std::move(c_obj)(x);
+        assert(Fn::check_call<int&>(CT_Const | CT_RValue));
+        std::move(c_obj)(cx);
+        assert(Fn::check_call<const int&>(CT_Const | CT_RValue));
+        std::move(c_obj)(std::move(x));
+        assert(Fn::check_call<int&&>(CT_Const | CT_RValue));
+        std::move(c_obj)(std::move(cx));
+        assert(Fn::check_call<const int&&>(CT_Const | CT_RValue));
+        std::move(c_obj)(42);
+        assert(Fn::check_call<int&&>(CT_Const | CT_RValue));
+    }
+    { // test multi arg
+        int x = 42;
+        const double y = 3.14;
+        std::string s = "abc";
+        obj(42, std::move(y), s, std::string{"foo"});
+        Fn::check_call<int&&, const double&&, std::string&, std::string&&>(CT_NonConst | CT_LValue);
+        std::move(obj)(42, std::move(y), s, std::string{"foo"});
+        Fn::check_call<int&&, const double&&, std::string&, std::string&&>(CT_NonConst | CT_RValue);
+        c_obj(42, std::move(y), s, std::string{"foo"});
+        Fn::check_call<int&&, const double&&, std::string&, std::string&&>(CT_Const  | CT_LValue);
+        std::move(c_obj)(42, std::move(y), s, std::string{"foo"});
+        Fn::check_call<int&&, const double&&, std::string&, std::string&&>(CT_Const  | CT_RValue);
+    }
+}
+
+void call_operator_noexcept_test()
+{
+    {
+        using T = ConstCallable<bool>;
+        T value(true);
+        auto ret = std::not_fn(value);
+        static_assert(!noexcept(ret()), "call should not be noexcept");
+        auto const& cret = ret;
+        static_assert(!noexcept(cret()), "call should not be noexcept");
+    }
+    {
+        using T = NoExceptCallable<bool>;
+        T value(true);
+        auto ret = std::not_fn(value);
+        static_assert(noexcept(!_VSTD::__invoke(value)), "");
+        static_assert(noexcept(ret()), "call should be noexcept");
+        auto const& cret = ret;
+        static_assert(noexcept(cret()), "call should be noexcept");
+    }
+    {
+        using T = NoExceptCallable<NoExceptEvilBool>;
+        T value(true);
+        auto ret = std::not_fn(value);
+        static_assert(noexcept(ret()), "call should not be noexcept");
+        auto const& cret = ret;
+        static_assert(noexcept(cret()), "call should not be noexcept");
+    }
+    {
+        using T = NoExceptCallable<EvilBool>;
+        T value(true);
+        auto ret = std::not_fn(value);
+        static_assert(!noexcept(ret()), "call should not be noexcept");
+        auto const& cret = ret;
+        static_assert(!noexcept(cret()), "call should not be noexcept");
+    }
+}
+
+int main()
+{
+    constructor_tests();
+    return_type_tests();
+    other_callable_types_test();
+    throws_in_constructor_test();
+    call_operator_sfinae_test(); // somewhat of an extension
+    call_operator_forwarding_test();
+    call_operator_noexcept_test();
+}
diff --git a/test/std/utilities/function.objects/func.require/INVOKE_tested_elsewhere.pass.cpp b/test/std/utilities/function.objects/func.require/INVOKE_tested_elsewhere.pass.cpp
new file mode 100644
index 000000000000..d61c3773e539
--- /dev/null
+++ b/test/std/utilities/function.objects/func.require/INVOKE_tested_elsewhere.pass.cpp
@@ -0,0 +1,16 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// INVOKE (f, t1, t2, ..., tN)
+
+// The tests for INVOKE (f, t1, t2, ..., tN) live in the "test/libcxx" tree
+// since they require calling the implementation specific "__invoke" and
+// "__invoke_constexpr" functions.
+
+int main() {}
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.pass.cpp
index aa6b743b5236..403d646f4216 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <functional>
 
 // class function<R(ArgTypes...)>
@@ -14,8 +16,10 @@
 // template<class A> function(allocator_arg_t, const A&, function&&);
 
 #include <functional>
+#include <memory>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 #include "count_new.hpp"
 
@@ -46,23 +50,57 @@ public:
 
 int A::count = 0;
 
+int g(int) { return 0; }
+
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     assert(globalMemCounter.checkOutstandingNewEq(0));
     {
-    std::function<int(int)> f = A();
-    assert(A::count == 1);
-    assert(globalMemCounter.checkOutstandingNewEq(1));
-    assert(f.target<A>());
-    assert(f.target<int(*)(int)>() == 0);
-    std::function<int(int)> f2(std::allocator_arg, bare_allocator<A>(), std::move(f));
-    assert(A::count == 1);
-    assert(globalMemCounter.checkOutstandingNewEq(1));
-    assert(f2.target<A>());
-    assert(f2.target<int(*)(int)>() == 0);
-    assert(f.target<A>() == 0);
-    assert(f.target<int(*)(int)>() == 0);
+        std::function<int(int)> f = A();
+        assert(A::count == 1);
+        assert(globalMemCounter.checkOutstandingNewEq(1));
+        assert(f.target<A>());
+        assert(f.target<int(*)(int)>() == 0);
+        std::function<int(int)> f2(std::allocator_arg, bare_allocator<A>(), std::move(f));
+        assert(A::count == 1);
+        assert(globalMemCounter.checkOutstandingNewEq(1));
+        assert(f2.target<A>());
+        assert(f2.target<int(*)(int)>() == 0);
+        assert(f.target<A>() == 0);
+        assert(f.target<int(*)(int)>() == 0);
+    }
+    assert(globalMemCounter.checkOutstandingNewEq(0));
+    {
+        // Test that moving a function constructed from a reference wrapper
+        // is done without allocating.
+        DisableAllocationGuard g;
+        using Ref = std::reference_wrapper<A>;
+        A a;
+        Ref aref(a);
+        std::function<int(int)> f(aref);
+        assert(A::count == 1);
+        assert(f.target<A>() == nullptr);
+        assert(f.target<Ref>());
+        std::function<int(int)> f2(std::allocator_arg, std::allocator<void>{},
+                                   std::move(f));
+        assert(A::count == 1);
+        assert(f2.target<A>() == nullptr);
+        assert(f2.target<Ref>());
+        assert(f.target<Ref>()); // f is unchanged because the target is small
+    }
+    {
+        // Test that moving a function constructed from a function pointer
+        // is done without allocating
+        DisableAllocationGuard guard;
+        using Ptr = int(*)(int);
+        Ptr p = g;
+        std::function<int(int)> f(p);
+        assert(f.target<A>() == nullptr);
+        assert(f.target<Ptr>());
+        std::function<int(int)> f2(std::allocator_arg, std::allocator<void>(),
+                                   std::move(f));
+        assert(f2.target<A>() == nullptr);
+        assert(f2.target<Ptr>());
+        assert(f.target<Ptr>()); // f is unchanged because the target is small
     }
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_move.pass.cpp
index f603da9dd131..387b371a9331 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_move.pass.cpp
@@ -14,9 +14,11 @@
 // function(const function& f);
 
 #include <functional>
+#include <memory>
 #include <cstdlib>
 #include <cassert>
 
+#include "test_macros.h"
 #include "count_new.hpp"
 
 class A
@@ -98,21 +100,53 @@ int main()
     assert(g.target<A>() == 0);
     assert(!g);
     }
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#if TEST_STD_VER >= 11
+    assert(globalMemCounter.checkOutstandingNewEq(0));
+    { // Test rvalue references
+        std::function<int(int)> f = A();
+        assert(A::count == 1);
+        assert(globalMemCounter.checkOutstandingNewEq(1));
+        assert(f.target<A>());
+        assert(f.target<int(*)(int)>() == 0);
+        std::function<int(int)> f2 = std::move(f);
+        assert(A::count == 1);
+        assert(globalMemCounter.checkOutstandingNewEq(1));
+        assert(f2.target<A>());
+        assert(f2.target<int(*)(int)>() == 0);
+        assert(f.target<A>() == 0);
+        assert(f.target<int(*)(int)>() == 0);
+    }
     assert(globalMemCounter.checkOutstandingNewEq(0));
     {
-    std::function<int(int)> f = A();
-    assert(A::count == 1);
-    assert(globalMemCounter.checkOutstandingNewEq(1));
-    assert(f.target<A>());
-    assert(f.target<int(*)(int)>() == 0);
-    std::function<int(int)> f2 = std::move(f);
-    assert(A::count == 1);
-    assert(globalMemCounter.checkOutstandingNewEq(1));
-    assert(f2.target<A>());
-    assert(f2.target<int(*)(int)>() == 0);
-    assert(f.target<A>() == 0);
-    assert(f.target<int(*)(int)>() == 0);
+        // Test that moving a function constructed from a reference wrapper
+        // is done without allocating.
+        DisableAllocationGuard g;
+        using Ref = std::reference_wrapper<A>;
+        A a;
+        Ref aref(a);
+        std::function<int(int)> f(aref);
+        assert(A::count == 1);
+        assert(f.target<A>() == nullptr);
+        assert(f.target<Ref>());
+        std::function<int(int)> f2(std::move(f));
+        assert(A::count == 1);
+        assert(f2.target<A>() == nullptr);
+        assert(f2.target<Ref>());
+        assert(f.target<Ref>()); // f is unchanged because the target is small
+    }
+    {
+        // Test that moving a function constructed from a function pointer
+        // is done without allocating
+        DisableAllocationGuard guard;
+        using Ptr = int(*)(int);
+        Ptr p = g;
+        std::function<int(int)> f(p);
+        assert(f.target<A>() == nullptr);
+        assert(f.target<Ptr>());
+        std::function<int(int)> f2(std::move(f));
+        assert(f2.target<A>() == nullptr);
+        assert(f2.target<Ptr>());
+        assert(f.target<Ptr>()); // f is unchanged because the target is small
     }
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif  // TEST_STD_VER >= 11
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/assign_F_alloc.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/assign_F_alloc.pass.cpp
index e9ecfa5539ce..cb45b30a9fd4 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/assign_F_alloc.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/assign_F_alloc.pass.cpp
@@ -12,10 +12,12 @@
 // class function<R(ArgTypes...)>
 
 // template<class F, class A> void assign(F&&, const A&);
+//     This call was removed post-C++14
 
 #include <functional>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_allocator.h"
 
 class A
@@ -49,6 +51,7 @@ int A::count = 0;
 
 int main()
 {
+#if TEST_STD_VER <= 14
     {
     std::function<int(int)> f;
     f.assign(A(), test_allocator<A>());
@@ -57,4 +60,5 @@ int main()
     assert(f.target<int(*)(int)>() == 0);
     }
     assert(A::count == 0);
+#endif
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/types.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/types.pass.cpp
index eb4eac65cd2c..e48b8f986916 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/types.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/types.pass.cpp
@@ -14,7 +14,7 @@
 // public:
 //   typedef R result_type;
 //   typedef T1 argument_type;          // iff sizeof...(ArgTypes) == 1 and
-//                                      // the type in ArgTypes is T1 
+//                                      // the type in ArgTypes is T1
 //   typedef T1 first_argument_type;    // iff sizeof...(ArgTypes) == 2 and
 //                                      // ArgTypes contains T1 and T2
 //   typedef T2 second_argument_type;   // iff sizeof...(ArgTypes) == 2 and
diff --git a/test/std/utilities/function.objects/logical.operations/transparent.pass.cpp b/test/std/utilities/function.objects/logical.operations/transparent.pass.cpp
index 6e3b7a2eee24..00e513ec546f 100644
--- a/test/std/utilities/function.objects/logical.operations/transparent.pass.cpp
+++ b/test/std/utilities/function.objects/logical.operations/transparent.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 #include <functional>
 #include <string>
 
@@ -22,9 +23,8 @@ public:
 };
 
 
-int main () {
-#if _LIBCPP_STD_VER > 11
-
+int main ()
+{
     static_assert ( !is_transparent<std::logical_and<int>>::value, "" );
     static_assert ( !is_transparent<std::logical_and<std::string>>::value, "" );
     static_assert (  is_transparent<std::logical_and<void>>::value, "" );
@@ -39,8 +39,6 @@ int main () {
     static_assert ( !is_transparent<std::logical_not<std::string>>::value, "" );
     static_assert (  is_transparent<std::logical_not<void>>::value, "" );
     static_assert (  is_transparent<std::logical_not<>>::value, "" );
-    
-#endif
 
     return 0;
-    }
+}
diff --git a/test/std/utilities/function.objects/refwrap/type_properties.pass.cpp b/test/std/utilities/function.objects/refwrap/type_properties.pass.cpp
index 61e0bfa162d8..3c00bd20ac64 100644
--- a/test/std/utilities/function.objects/refwrap/type_properties.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/type_properties.pass.cpp
@@ -14,6 +14,9 @@
 // Test that reference wrapper meets the requirements of TriviallyCopyable,
 // CopyConstructible and CopyAssignable.
 
+// Test fails due to use of is_trivially_* trait.
+// XFAIL: gcc-4.9
+
 #include <functional>
 #include <type_traits>
 #include <string>
@@ -51,8 +54,8 @@ int main()
 {
     test<int>();
     test<double>();
-    test<std::string>(); 
+    test<std::string>();
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    test<MoveOnly>(); 
+    test<MoveOnly>();
 #endif
 }
diff --git a/test/std/utilities/function.objects/unord.hash/enum.pass.cpp b/test/std/utilities/function.objects/unord.hash/enum.pass.cpp
index bd92a4ac4d2e..8aa2c1df8935 100644
--- a/test/std/utilities/function.objects/unord.hash/enum.pass.cpp
+++ b/test/std/utilities/function.objects/unord.hash/enum.pass.cpp
@@ -12,7 +12,9 @@
 // make sure that we can hash enumeration values
 // Not very portable
 
-#if __cplusplus >= 201402L
+#include "test_macros.h"
+
+#if TEST_STD_VER >= 14
 
 #include <functional>
 #include <cassert>
@@ -35,7 +37,7 @@ test()
     static_assert((std::is_same<typename H::argument_type, T>::value), "" );
     static_assert((std::is_same<typename H::result_type, std::size_t>::value), "" );
     typedef typename std::underlying_type<T>::type under_type;
-    
+
     H h1;
     std::hash<under_type> h2;
     for (int i = 0; i <= 5; ++i)
diff --git a/test/std/utilities/function.objects/unord.hash/floating.pass.cpp b/test/std/utilities/function.objects/unord.hash/floating.pass.cpp
index f1f198f23599..643e2d8c5d86 100644
--- a/test/std/utilities/function.objects/unord.hash/floating.pass.cpp
+++ b/test/std/utilities/function.objects/unord.hash/floating.pass.cpp
@@ -35,7 +35,7 @@ test()
 
     std::size_t t0 = h(0.);
     std::size_t tn0 = h(-0.);
-    std::size_t tp1 = h(0.1);
+    std::size_t tp1 = h(static_cast<T>(0.1));
     std::size_t t1 = h(1);
     std::size_t tn1 = h(-1);
     std::size_t pinf = h(INFINITY);
diff --git a/test/std/utilities/function.objects/unord.hash/integral.pass.cpp b/test/std/utilities/function.objects/unord.hash/integral.pass.cpp
index c20f31ff2c99..8954f4f3664b 100644
--- a/test/std/utilities/function.objects/unord.hash/integral.pass.cpp
+++ b/test/std/utilities/function.objects/unord.hash/integral.pass.cpp
@@ -16,14 +16,14 @@
 //     size_t operator()(T val) const;
 // };
 
-// Not very portable
-
 #include <functional>
 #include <cassert>
 #include <type_traits>
 #include <cstddef>
 #include <limits>
 
+#include "test_macros.h"
+
 template <class T>
 void
 test()
@@ -37,7 +37,11 @@ test()
     {
         T t(i);
         if (sizeof(T) <= sizeof(std::size_t))
-            assert(h(t) == t);
+        {
+            const std::size_t result = h(t);
+            LIBCPP_ASSERT(result == t);
+            ((void)result); // Prevent unused warning
+        }
     }
 }
 
@@ -67,7 +71,7 @@ int main()
 	test<int16_t>();
 	test<int32_t>();
 	test<int64_t>();
-	
+
 	test<int_fast8_t>();
 	test<int_fast16_t>();
 	test<int_fast32_t>();
@@ -80,12 +84,12 @@ int main()
 
     test<intmax_t>();
     test<intptr_t>();
-	
+
 	test<uint8_t>();
 	test<uint16_t>();
 	test<uint32_t>();
 	test<uint64_t>();
-	
+
 	test<uint_fast8_t>();
 	test<uint_fast16_t>();
 	test<uint_fast32_t>();
@@ -98,4 +102,9 @@ int main()
 
     test<uintmax_t>();
     test<uintptr_t>();
+
+#ifndef _LIBCPP_HAS_NO_INT128
+    test<__int128_t>();
+    test<__uint128_t>();
+#endif
 }
diff --git a/test/std/utilities/intseq/intseq.general/integer_seq.pass.cpp b/test/std/utilities/intseq/intseq.general/integer_seq.pass.cpp
index 8ca5a96a4fac..653fbc43d301 100644
--- a/test/std/utilities/intseq/intseq.general/integer_seq.pass.cpp
+++ b/test/std/utilities/intseq/intseq.general/integer_seq.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <utility>
 
 // class make_integer_sequence
@@ -16,19 +17,13 @@
 #include <type_traits>
 #include <cassert>
 
-#if _LIBCPP_STD_VER > 11
-
 template <typename AtContainer, typename T, T... I>
-auto extract ( const AtContainer &t, const std::integer_sequence<T, I...> idx )
+auto extract ( const AtContainer &t, const std::integer_sequence<T, I...> )
 -> decltype ( std::make_tuple ( std::get<I>(t)... ))
 {     return  std::make_tuple ( std::get<I>(t)... ); }
 
-#endif  // _LIBCPP_STD_VER > 11
-
 int main()
 {
-#if _LIBCPP_STD_VER > 11
-
 //  Make a couple of sequences
     using int3    = std::make_integer_sequence<int, 3>;     // generates int:    0,1,2
     using size7   = std::make_integer_sequence<size_t, 7>;  // generates size_t: 0,1,2,3,4,5,6
@@ -36,20 +31,20 @@ int main()
     using size2   = std::index_sequence_for<int, size_t>;   // generates size_t: 0,1
     using intmix  = std::integer_sequence<int, 9, 8, 7, 2>; // generates int:    9,8,7,2
     using sizemix = std::index_sequence<1, 1, 2, 3, 5>;     // generates size_t: 1,1,2,3,5
-    
+
 //  Make sure they're what we expect
     static_assert ( std::is_same<int3::value_type, int>::value, "int3 type wrong" );
     static_assert ( int3::size () == 3, "int3 size wrong" );
-    
+
     static_assert ( std::is_same<size7::value_type, size_t>::value, "size7 type wrong" );
     static_assert ( size7::size () == 7, "size7 size wrong" );
-    
+
     static_assert ( std::is_same<size4::value_type, size_t>::value, "size4 type wrong" );
     static_assert ( size4::size () == 4, "size4 size wrong" );
-    
+
     static_assert ( std::is_same<size2::value_type, size_t>::value, "size2 type wrong" );
     static_assert ( size2::size () == 2, "size2 size wrong" );
-    
+
     static_assert ( std::is_same<intmix::value_type, int>::value, "intmix type wrong" );
     static_assert ( intmix::size () == 4, "intmix size wrong" );
 
@@ -57,7 +52,7 @@ int main()
     static_assert ( sizemix::size () == 5, "sizemix size wrong" );
 
     auto tup = std::make_tuple ( 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 );
-    
+
 //  Use them
     auto t3 = extract ( tup, int3() );
     static_assert ( std::tuple_size<decltype(t3)>::value == int3::size (), "t3 size wrong");
@@ -82,5 +77,4 @@ int main()
     auto tsizemix = extract ( tup, sizemix ());
     static_assert ( std::tuple_size<decltype(tsizemix)>::value == sizemix::size (), "tsizemix size wrong");
     assert ( tsizemix == std::make_tuple ( 11, 11, 12, 13, 15 ));
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/utilities/intseq/intseq.intseq/integer_seq.fail.cpp b/test/std/utilities/intseq/intseq.intseq/integer_seq.fail.cpp
index 4b2d1acb5e6b..b689160babaa 100644
--- a/test/std/utilities/intseq/intseq.intseq/integer_seq.fail.cpp
+++ b/test/std/utilities/intseq/intseq.intseq/integer_seq.fail.cpp
@@ -13,7 +13,7 @@
 // struct integer_sequence
 // {
 //     typedef T type;
-// 
+//
 //     static constexpr size_t size() noexcept;
 // };
 
diff --git a/test/std/utilities/intseq/intseq.intseq/integer_seq.pass.cpp b/test/std/utilities/intseq/intseq.intseq/integer_seq.pass.cpp
index 5c789f5db274..841a234334b7 100644
--- a/test/std/utilities/intseq/intseq.intseq/integer_seq.pass.cpp
+++ b/test/std/utilities/intseq/intseq.intseq/integer_seq.pass.cpp
@@ -7,13 +7,14 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <utility>
 
 // template<class T, T... I>
 // struct integer_sequence
 // {
 //     typedef T type;
-// 
+//
 //     static constexpr size_t size() noexcept;
 // };
 
@@ -24,26 +25,22 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
-
 //  Make a few of sequences
     using int3    = std::integer_sequence<int, 3, 2, 1>;
     using size1   = std::integer_sequence<std::size_t, 7>;
     using ushort2 = std::integer_sequence<unsigned short, 4, 6>;
     using bool0   = std::integer_sequence<bool>;
-    
+
 //  Make sure they're what we expect
     static_assert ( std::is_same<int3::value_type, int>::value, "int3 type wrong" );
     static_assert ( int3::size() == 3, "int3 size wrong" );
-    
+
     static_assert ( std::is_same<size1::value_type, std::size_t>::value, "size1 type wrong" );
     static_assert ( size1::size() == 1, "size1 size wrong" );
-    
+
     static_assert ( std::is_same<ushort2::value_type, unsigned short>::value, "ushort2 type wrong" );
     static_assert ( ushort2::size() == 2, "ushort2 size wrong" );
-    
+
     static_assert ( std::is_same<bool0::value_type, bool>::value, "bool0 type wrong" );
     static_assert ( bool0::size() == 0, "bool0 size wrong" );
-    
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.members/max_size.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.members/max_size.pass.cpp
index 352c7c8d0caf..bbc6b470174d 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.members/max_size.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.members/max_size.pass.cpp
@@ -21,6 +21,8 @@
 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <class T>
 struct A
 {
@@ -61,7 +63,7 @@ int main()
         const B<int> b = {};
         assert(std::allocator_traits<B<int> >::max_size(b) == 100);
     }
-#if __cplusplus >= 201103
+#if TEST_STD_VER >= 11
     {
         std::allocator<int> a;
         static_assert(noexcept(std::allocator_traits<std::allocator<int>>::max_size(a)) == true, "");
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.types/const_pointer.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.types/const_pointer.pass.cpp
index 20348d20c10c..10fbfe141ae5 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.types/const_pointer.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.types/const_pointer.pass.cpp
@@ -20,6 +20,8 @@
 #include <memory>
 #include <type_traits>
 
+#include "test_macros.h"
+
 template <class T>
 struct Ptr {};
 
@@ -47,9 +49,19 @@ struct C
     typedef CPtr<const T> const_pointer;
 };
 
+template <class T>
+struct D {
+  typedef T value_type;
+private:
+  typedef void const_pointer;
+};
+
 int main()
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::const_pointer, Ptr<const char> >::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::const_pointer, const char*>::value), "");
     static_assert((std::is_same<std::allocator_traits<C<char> >::const_pointer, CPtr<const char> >::value), "");
+#if TEST_STD_VER >= 11
+    static_assert((std::is_same<std::allocator_traits<D<char> >::const_pointer, const char*>::value), "");
+#endif
 }
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.types/const_void_pointer.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.types/const_void_pointer.pass.cpp
index 4b4045a51bae..8365d22613ee 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.types/const_void_pointer.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.types/const_void_pointer.pass.cpp
@@ -21,6 +21,8 @@
 #include <memory>
 #include <type_traits>
 
+#include "test_macros.h"
+
 template <class T>
 struct Ptr {};
 
@@ -47,9 +49,21 @@ struct C
     typedef CPtr<const void> const_void_pointer;
 };
 
+
+template <class T>
+struct D
+{
+    typedef T value_type;
+private:
+    typedef int const_void_pointer;
+};
+
 int main()
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::const_void_pointer, Ptr<const void> >::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::const_void_pointer, const void*>::value), "");
     static_assert((std::is_same<std::allocator_traits<C<char> >::const_void_pointer, CPtr<const void> >::value), "");
+#if TEST_STD_VER >= 11
+    static_assert((std::is_same<std::allocator_traits<D<char> >::const_void_pointer, const void*>::value), "");
+#endif
 }
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.types/difference_type.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.types/difference_type.pass.cpp
index 085c911b0703..c728909477b5 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.types/difference_type.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.types/difference_type.pass.cpp
@@ -20,6 +20,8 @@
 #include <memory>
 #include <type_traits>
 
+#include "test_macros.h"
+
 template <class T>
 struct A
 {
@@ -43,13 +45,24 @@ struct C
     struct const_void_pointer {};
 };
 
+
+template <class T>
+struct D
+{
+    typedef T value_type;
+private:
+    typedef void difference_type;
+};
+
 namespace std
 {
 
 template <>
 struct pointer_traits<C<char>::pointer>
 {
-    typedef signed char difference_type;
+    typedef C<char>::pointer pointer;
+    typedef char             element_type;
+    typedef signed char      difference_type;
 };
 
 }
@@ -59,4 +72,7 @@ int main()
     static_assert((std::is_same<std::allocator_traits<A<char> >::difference_type, short>::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::difference_type, std::ptrdiff_t>::value), "");
     static_assert((std::is_same<std::allocator_traits<C<char> >::difference_type, signed char>::value), "");
+#if TEST_STD_VER >= 11
+    static_assert((std::is_same<std::allocator_traits<D<char> >::difference_type, std::ptrdiff_t>::value), "");
+#endif
 }
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.types/pointer.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.types/pointer.pass.cpp
index 60ba09499342..ff1ae2c051b6 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.types/pointer.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.types/pointer.pass.cpp
@@ -19,6 +19,8 @@
 #include <memory>
 #include <type_traits>
 
+#include "test_macros.h"
+
 template <class T>
 struct Ptr {};
 
@@ -35,8 +37,18 @@ struct B
     typedef T value_type;
 };
 
+template <class T>
+struct C {
+    typedef T value_type;
+private:
+    typedef void pointer;
+};
+
 int main()
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::pointer, Ptr<char> >::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::pointer, char*>::value), "");
+#if TEST_STD_VER >= 11
+    static_assert((std::is_same<std::allocator_traits<C<char> >::pointer, char*>::value), "");
+#endif
 }
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_copy_assignment.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_copy_assignment.pass.cpp
index 604e890efaae..0112ab371a83 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_copy_assignment.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_copy_assignment.pass.cpp
@@ -20,6 +20,8 @@
 #include <memory>
 #include <type_traits>
 
+#include "test_macros.h"
+
 template <class T>
 struct A
 {
@@ -33,8 +35,20 @@ struct B
     typedef T value_type;
 };
 
+
+template <class T>
+struct C
+{
+    typedef T value_type;
+private:
+    typedef std::true_type propagate_on_container_copy_assignment;
+};
+
 int main()
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::propagate_on_container_copy_assignment, std::true_type>::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::propagate_on_container_copy_assignment, std::false_type>::value), "");
+#if TEST_STD_VER >= 11
+    static_assert((std::is_same<std::allocator_traits<C<char> >::propagate_on_container_copy_assignment, std::false_type>::value), "");
+#endif
 }
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_move_assignment.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_move_assignment.pass.cpp
index 1d2b18686d0f..64de15c2cd48 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_move_assignment.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_move_assignment.pass.cpp
@@ -20,6 +20,8 @@
 #include <memory>
 #include <type_traits>
 
+#include "test_macros.h"
+
 template <class T>
 struct A
 {
@@ -33,8 +35,21 @@ struct B
     typedef T value_type;
 };
 
+
+template <class T>
+struct C
+{
+    typedef T value_type;
+private:
+    typedef std::true_type propagate_on_container_move_assignment;
+};
+
+
 int main()
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::propagate_on_container_move_assignment, std::true_type>::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::propagate_on_container_move_assignment, std::false_type>::value), "");
+#if TEST_STD_VER >= 11
+    static_assert((std::is_same<std::allocator_traits<C<char> >::propagate_on_container_move_assignment, std::false_type>::value), "");
+#endif
 }
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_swap.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_swap.pass.cpp
index 6730d1ae261a..a62336fa6cb0 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_swap.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_swap.pass.cpp
@@ -20,6 +20,8 @@
 #include <memory>
 #include <type_traits>
 
+#include "test_macros.h"
+
 template <class T>
 struct A
 {
@@ -33,8 +35,19 @@ struct B
     typedef T value_type;
 };
 
+template <class T>
+struct C
+{
+    typedef T value_type;
+private:
+    typedef std::true_type propagate_on_container_swap;
+};
+
 int main()
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::propagate_on_container_swap, std::true_type>::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::propagate_on_container_swap, std::false_type>::value), "");
+ #if TEST_STD_VER >= 11
+    static_assert((std::is_same<std::allocator_traits<C<char> >::propagate_on_container_swap, std::false_type>::value), "");
+#endif
 }
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.types/rebind_alloc.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.types/rebind_alloc.pass.cpp
index 50611b99da9a..8097a66fc9d6 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.types/rebind_alloc.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.types/rebind_alloc.pass.cpp
@@ -19,6 +19,8 @@
 #include <memory>
 #include <type_traits>
 
+#include "test_macros.h"
+
 template <class T>
 struct ReboundA {};
 
@@ -61,19 +63,39 @@ struct E
     template <class U> struct rebind {typedef ReboundA<U> otter;};
 };
 
+template <class T>
+struct F {
+    typedef T value_type;
+private:
+    template <class>
+    struct rebind { typedef void other; };
+};
+
+template <class T>
+struct G {
+    typedef T value_type;
+    template <class>
+    struct rebind {
+    private:
+        typedef void other;
+    };
+};
+
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#if TEST_STD_VER >= 11
     static_assert((std::is_same<std::allocator_traits<A<char> >::rebind_alloc<double>, ReboundA<double> >::value), "");
     static_assert((std::is_same<std::allocator_traits<B<int, char> >::rebind_alloc<double>, ReboundB<double, char> >::value), "");
     static_assert((std::is_same<std::allocator_traits<C<char> >::rebind_alloc<double>, C<double> >::value), "");
     static_assert((std::is_same<std::allocator_traits<D<int, char> >::rebind_alloc<double>, D<double, char> >::value), "");
     static_assert((std::is_same<std::allocator_traits<E<char> >::rebind_alloc<double>, E<double> >::value), "");
-#else  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+    static_assert((std::is_same<std::allocator_traits<F<char> >::rebind_alloc<double>, F<double> >::value), "");
+    static_assert((std::is_same<std::allocator_traits<G<char> >::rebind_alloc<double>, G<double> >::value), "");
+#else
     static_assert((std::is_same<std::allocator_traits<A<char> >::rebind_alloc<double>::other, ReboundA<double> >::value), "");
     static_assert((std::is_same<std::allocator_traits<B<int, char> >::rebind_alloc<double>::other, ReboundB<double, char> >::value), "");
     static_assert((std::is_same<std::allocator_traits<C<char> >::rebind_alloc<double>::other, C<double> >::value), "");
     static_assert((std::is_same<std::allocator_traits<D<int, char> >::rebind_alloc<double>::other, D<double, char> >::value), "");
     static_assert((std::is_same<std::allocator_traits<E<char> >::rebind_alloc<double>::other, E<double> >::value), "");
-#endif  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#endif
 }
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.types/size_type.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.types/size_type.pass.cpp
index e9c175fe86a5..00ed50727c98 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.types/size_type.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.types/size_type.pass.cpp
@@ -19,6 +19,8 @@
 #include <memory>
 #include <type_traits>
 
+#include "test_macros.h"
+
 template <class T>
 struct A
 {
@@ -42,6 +44,14 @@ struct C
     struct const_void_pointer {};
 };
 
+template <class T>
+struct D {
+    typedef T value_type;
+    typedef short difference_type;
+private:
+    typedef void size_type;
+};
+
 namespace std
 {
 
@@ -60,4 +70,7 @@ int main()
                    std::make_unsigned<std::ptrdiff_t>::type>::value), "");
     static_assert((std::is_same<std::allocator_traits<C<char> >::size_type,
                    unsigned char>::value), "");
+#if TEST_STD_VER >= 11
+    static_assert((std::is_same<std::allocator_traits<D<char> >::size_type, unsigned short>::value), "");
+#endif
 }
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.types/void_pointer.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.types/void_pointer.pass.cpp
index 74cd3475f664..2c3623793db6 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.types/void_pointer.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.types/void_pointer.pass.cpp
@@ -20,6 +20,7 @@
 
 #include <memory>
 #include <type_traits>
+#include "test_macros.h"
 
 template <class T>
 struct Ptr {};
@@ -47,9 +48,21 @@ struct C
     typedef CPtr<void> void_pointer;
 };
 
+
+template <class T>
+struct D
+{
+    typedef T value_type;
+private:
+    typedef void void_pointer;
+};
+
 int main()
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::void_pointer, Ptr<void> >::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::void_pointer, void*>::value), "");
     static_assert((std::is_same<std::allocator_traits<C<char> >::void_pointer, CPtr<void> >::value), "");
+#if TEST_STD_VER >= 11
+    static_assert((std::is_same<std::allocator_traits<D<char> >::void_pointer, void*>::value), "");
+#endif
 }
diff --git a/test/std/utilities/memory/allocator.uses/allocator.uses.trait/uses_allocator.pass.cpp b/test/std/utilities/memory/allocator.uses/allocator.uses.trait/uses_allocator.pass.cpp
index 0477d9912e6e..bd32bc34e7a0 100644
--- a/test/std/utilities/memory/allocator.uses/allocator.uses.trait/uses_allocator.pass.cpp
+++ b/test/std/utilities/memory/allocator.uses/allocator.uses.trait/uses_allocator.pass.cpp
@@ -14,6 +14,8 @@
 #include <memory>
 #include <vector>
 
+#include "test_macros.h"
+
 struct A
 {
 };
@@ -23,6 +25,19 @@ struct B
     typedef int allocator_type;
 };
 
+struct C {
+  static int allocator_type;
+};
+
+struct D {
+  static int allocator_type() { return 0; }
+};
+
+struct E {
+private:
+  typedef int allocator_type;
+};
+
 int main()
 {
     static_assert((!std::uses_allocator<int, std::allocator<int> >::value), "");
@@ -30,4 +45,9 @@ int main()
     static_assert((!std::uses_allocator<A, std::allocator<int> >::value), "");
     static_assert((!std::uses_allocator<B, std::allocator<int> >::value), "");
     static_assert(( std::uses_allocator<B, double>::value), "");
+    static_assert((!std::uses_allocator<C, decltype(C::allocator_type)>::value), "");
+    static_assert((!std::uses_allocator<D, decltype(D::allocator_type)>::value), "");
+#if TEST_STD_VER >= 11
+    static_assert((!std::uses_allocator<E, int>::value), "");
+#endif
 }
diff --git a/test/std/utilities/memory/default.allocator/allocator.members/allocate.size.pass.cpp b/test/std/utilities/memory/default.allocator/allocator.members/allocate.size.pass.cpp
new file mode 100644
index 000000000000..dc0bdd047c61
--- /dev/null
+++ b/test/std/utilities/memory/default.allocator/allocator.members/allocate.size.pass.cpp
@@ -0,0 +1,49 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// XFAIL: libcpp-no-exceptions
+// <memory>
+
+// allocator:
+// pointer allocate(size_type n, allocator<void>::const_pointer hint=0);
+
+#include <memory>
+#include <cassert>
+
+template <typename T>
+void test_max(size_t count)
+{
+    std::allocator<T> a;
+    try {
+        a.allocate(count);
+        assert(false);
+    } catch (const std::exception &) {
+    }
+}
+
+int main()
+{
+    {  // Bug 26812 -- allocating too large
+        typedef double T;
+        std::allocator<T> a;
+        test_max<T> (a.max_size() + 1);                // just barely too large
+        test_max<T> (a.max_size() * 2);                // significantly too large
+        test_max<T> (((size_t) -1) / sizeof(T) + 1);   // multiply will overflow
+        test_max<T> ((size_t) -1);                     // way too large
+    }
+
+    {
+        typedef const double T;
+        std::allocator<T> a;
+        test_max<T> (a.max_size() + 1);                // just barely too large
+        test_max<T> (a.max_size() * 2);                // significantly too large
+        test_max<T> (((size_t) -1) / sizeof(T) + 1);   // multiply will overflow
+        test_max<T> ((size_t) -1);                     // way too large
+    }
+}
diff --git a/test/std/utilities/memory/default.allocator/allocator_pointers.pass.cpp b/test/std/utilities/memory/default.allocator/allocator_pointers.pass.cpp
index 5a8f7a28a042..e1612ae05421 100644
--- a/test/std/utilities/memory/default.allocator/allocator_pointers.pass.cpp
+++ b/test/std/utilities/memory/default.allocator/allocator_pointers.pass.cpp
@@ -10,7 +10,9 @@
 #include <memory>
 #include <cassert>
 
-#if __cplusplus >= 201103L
+#include "test_macros.h"
+
+#if TEST_STD_VER >= 11
 // #include <memory>
 //
 // template <class Alloc>
@@ -19,7 +21,7 @@
 //     typedef Alloc                        allocator_type;
 //     typedef typename allocator_type::value_type
 //                                          value_type;
-// 
+//
 //     typedef Alloc::pointer | value_type* pointer;
 //     typedef Alloc::const_pointer
 //           | pointer_traits<pointer>::rebind<const value_type>
@@ -36,7 +38,10 @@ void test_pointer()
 {
      typename std::allocator_traits<Alloc>::pointer        vp;
      typename std::allocator_traits<Alloc>::const_pointer cvp;
-     
+
+     ((void)vp); // Prevent unused warning
+     ((void)cvp); // Prevent unused warning
+
      static_assert(std::is_same<bool, decltype( vp ==  vp)>::value, "");
      static_assert(std::is_same<bool, decltype( vp !=  vp)>::value, "");
      static_assert(std::is_same<bool, decltype( vp >   vp)>::value, "");
@@ -70,7 +75,10 @@ void test_void_pointer()
 {
      typename std::allocator_traits<Alloc>::void_pointer        vp;
      typename std::allocator_traits<Alloc>::const_void_pointer cvp;
-     
+
+     ((void)vp); // Prevent unused warning
+     ((void)cvp); // Prevent unused warning
+
      static_assert(std::is_same<bool, decltype( vp ==  vp)>::value, "");
      static_assert(std::is_same<bool, decltype( vp !=  vp)>::value, "");
      static_assert(std::is_same<bool, decltype( vp >   vp)>::value, "");
@@ -105,11 +113,11 @@ int main()
 {
     test_pointer<std::allocator<char>> ();
     test_pointer<std::allocator<int>> ();
-    test_pointer<std::allocator<Foo>> ();   
+    test_pointer<std::allocator<Foo>> ();
 
     test_void_pointer<std::allocator<char>> ();
     test_void_pointer<std::allocator<int>> ();
-    test_void_pointer<std::allocator<Foo>> ();  
+    test_void_pointer<std::allocator<Foo>> ();
 }
 #else
 int main() {}
diff --git a/test/std/utilities/memory/pointer.traits/pointer.traits.types/difference_type.pass.cpp b/test/std/utilities/memory/pointer.traits/pointer.traits.types/difference_type.pass.cpp
index 4efe61342420..27b2d08b0061 100644
--- a/test/std/utilities/memory/pointer.traits/pointer.traits.types/difference_type.pass.cpp
+++ b/test/std/utilities/memory/pointer.traits/pointer.traits.types/difference_type.pass.cpp
@@ -19,6 +19,8 @@
 #include <memory>
 #include <type_traits>
 
+#include "test_macros.h"
+
 struct A
 {
     typedef short element_type;
@@ -39,10 +41,26 @@ struct D
     typedef char difference_type;
 };
 
+template <class T>
+struct E
+{
+    static int difference_type;
+};
+
+template <class T>
+struct F {
+private:
+  typedef int difference_type;
+};
+
 int main()
 {
     static_assert((std::is_same<std::pointer_traits<A>::difference_type, char>::value), "");
     static_assert((std::is_same<std::pointer_traits<B>::difference_type, std::ptrdiff_t>::value), "");
     static_assert((std::is_same<std::pointer_traits<C<double> >::difference_type, std::ptrdiff_t>::value), "");
     static_assert((std::is_same<std::pointer_traits<D<int> >::difference_type, char>::value), "");
+    static_assert((std::is_same<std::pointer_traits<E<int> >::difference_type, std::ptrdiff_t>::value), "");
+#if TEST_STD_VER >= 11
+    static_assert((std::is_same<std::pointer_traits<F<int>>::difference_type, std::ptrdiff_t>::value), "");
+#endif
 }
diff --git a/test/std/utilities/memory/pointer.traits/pointer.traits.types/element_type.pass.cpp b/test/std/utilities/memory/pointer.traits/pointer.traits.types/element_type.pass.cpp
index 0ee1e8c93a67..48399d5355d6 100644
--- a/test/std/utilities/memory/pointer.traits/pointer.traits.types/element_type.pass.cpp
+++ b/test/std/utilities/memory/pointer.traits/pointer.traits.types/element_type.pass.cpp
@@ -19,6 +19,8 @@
 #include <memory>
 #include <type_traits>
 
+#include "test_macros.h"
+
 struct A
 {
     typedef char element_type;
@@ -40,10 +42,27 @@ struct D
 {
 };
 
+template <class T, class U>
+struct E
+{
+    static int element_type;
+};
+
+template <class T>
+struct F {
+private:
+  typedef int element_type;
+};
+
 int main()
 {
     static_assert((std::is_same<std::pointer_traits<A>::element_type, char>::value), "");
     static_assert((std::is_same<std::pointer_traits<B<int> >::element_type, char>::value), "");
     static_assert((std::is_same<std::pointer_traits<C<int> >::element_type, int>::value), "");
     static_assert((std::is_same<std::pointer_traits<D<double, int> >::element_type, double>::value), "");
+    static_assert((std::is_same<std::pointer_traits<E<double, int> >::element_type, double>::value), "");
+#if TEST_STD_VER >= 11
+    static_assert((std::is_same<std::pointer_traits<F<double>>::element_type, double>::value), "");
+#endif
+
 }
diff --git a/test/std/utilities/memory/pointer.traits/pointer.traits.types/rebind.pass.cpp b/test/std/utilities/memory/pointer.traits/pointer.traits.types/rebind.pass.cpp
index 4a1455c53ef6..74c124901211 100644
--- a/test/std/utilities/memory/pointer.traits/pointer.traits.types/rebind.pass.cpp
+++ b/test/std/utilities/memory/pointer.traits/pointer.traits.types/rebind.pass.cpp
@@ -19,6 +19,8 @@
 #include <memory>
 #include <type_traits>
 
+#include "test_macros.h"
+
 template <class T>
 struct A
 {
@@ -29,7 +31,7 @@ template <class T> struct B1 {};
 template <class T>
 struct B
 {
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#if TEST_STD_VER >= 11
     template <class U> using rebind = B1<U>;
 #else
     template <class U> struct rebind {typedef B1<U> other;};
@@ -46,24 +48,58 @@ template <class T, class U> struct D1 {};
 template <class T, class U>
 struct D
 {
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#if TEST_STD_VER >= 11
     template <class V> using rebind = D1<V, U>;
 #else
     template <class V> struct rebind {typedef D1<V, U> other;};
 #endif
 };
 
+template <class T, class U>
+struct E
+{
+    template <class>
+    void rebind() {}
+};
+
+
+#if TEST_STD_VER >= 11
+template <class T, class U>
+struct F {
+private:
+  template <class>
+  using rebind = void;
+};
+#endif
+
+#if TEST_STD_VER >= 14
+template <class T, class U>
+struct G
+{
+    template <class>
+    static constexpr int rebind = 42;
+};
+#endif
+
+
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#if TEST_STD_VER >= 11
     static_assert((std::is_same<std::pointer_traits<A<int*> >::rebind<double*>, A<double*> >::value), "");
     static_assert((std::is_same<std::pointer_traits<B<int> >::rebind<double>, B1<double> >::value), "");
     static_assert((std::is_same<std::pointer_traits<C<char, int> >::rebind<double>, C<double, int> >::value), "");
     static_assert((std::is_same<std::pointer_traits<D<char, int> >::rebind<double>, D1<double, int> >::value), "");
-#else  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+    static_assert((std::is_same<std::pointer_traits<E<char, int> >::rebind<double>, E<double, int> >::value), "");
+    static_assert((std::is_same<std::pointer_traits<F<char, int> >::rebind<double>, F<double, int> >::value), "");
+
+#if TEST_STD_VER >= 14
+    static_assert((std::is_same<std::pointer_traits<G<char, int> >::rebind<double>, G<double, int> >::value), "");
+#endif
+#else  // TEST_STD_VER < 11
     static_assert((std::is_same<std::pointer_traits<A<int*> >::rebind<double*>::other, A<double*> >::value), "");
     static_assert((std::is_same<std::pointer_traits<B<int> >::rebind<double>::other, B1<double> >::value), "");
     static_assert((std::is_same<std::pointer_traits<C<char, int> >::rebind<double>::other, C<double, int> >::value), "");
     static_assert((std::is_same<std::pointer_traits<D<char, int> >::rebind<double>::other, D1<double, int> >::value), "");
-#endif  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+    static_assert((std::is_same<std::pointer_traits<E<char, int> >::rebind<double>::other, E<double, int> >::value), "");
+#endif
 }
diff --git a/test/std/utilities/memory/specialized.algorithms/specialized.addressof/constexpr_addressof.pass.cpp b/test/std/utilities/memory/specialized.algorithms/specialized.addressof/constexpr_addressof.pass.cpp
new file mode 100644
index 000000000000..a371f8eda1a8
--- /dev/null
+++ b/test/std/utilities/memory/specialized.algorithms/specialized.addressof/constexpr_addressof.pass.cpp
@@ -0,0 +1,42 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11, c++14
+// XFAIL: gcc
+
+// <memory>
+
+// template <ObjectType T> constexpr T* addressof(T& r);
+
+#include <memory>
+#include <cassert>
+
+struct Pointer {
+  constexpr Pointer(void* v) : value(v) {}
+  void* value;
+};
+
+struct A
+{
+    constexpr A() : n(42) {}
+    void operator&() const { }
+    int n;
+};
+
+constexpr int i = 0;
+constexpr double d = 0.0;
+constexpr A a{};
+
+int main()
+{
+    static_assert(std::addressof(i) == &i, "");
+    static_assert(std::addressof(d) == &d, "");
+    constexpr const A* ap = std::addressof(a);
+    static_assert(&ap->n == &a.n, "");
+}
diff --git a/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy.pass.cpp b/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy.pass.cpp
index 8bb818319a37..1debd6d75ff0 100644
--- a/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy.pass.cpp
@@ -36,7 +36,7 @@ struct Nasty
     Nasty() : i_ ( counter_++ ) {}
     Nasty * operator &() const { return NULL; }
     int i_;
-    static int counter_; 
+    static int counter_;
 };
 
 int Nasty::counter_ = 0;
@@ -76,5 +76,5 @@ int main()
         assert(  p[i].i_ == i);
         }
     }
-    
+
 }
diff --git a/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy_n.pass.cpp b/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy_n.pass.cpp
index ae438ef7d561..83aa19471ada 100644
--- a/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy_n.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy_n.pass.cpp
@@ -36,7 +36,7 @@ struct Nasty
     Nasty() : i_ ( counter_++ ) {}
     Nasty * operator &() const { return NULL; }
     int i_;
-    static int counter_; 
+    static int counter_;
 };
 
 int Nasty::counter_ = 0;
diff --git a/test/std/utilities/memory/specialized.algorithms/uninitialized.fill.n/uninitialized_fill_n.pass.cpp b/test/std/utilities/memory/specialized.algorithms/uninitialized.fill.n/uninitialized_fill_n.pass.cpp
index 22aa8b98b8c9..5f90a3792064 100644
--- a/test/std/utilities/memory/specialized.algorithms/uninitialized.fill.n/uninitialized_fill_n.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/uninitialized.fill.n/uninitialized_fill_n.pass.cpp
@@ -35,7 +35,7 @@ struct Nasty
     Nasty() : i_ ( counter_++ ) {}
     Nasty * operator &() const { return NULL; }
     int i_;
-    static int counter_; 
+    static int counter_;
 };
 
 int Nasty::counter_ = 0;
diff --git a/test/std/utilities/memory/specialized.algorithms/uninitialized.fill/uninitialized_fill.pass.cpp b/test/std/utilities/memory/specialized.algorithms/uninitialized.fill/uninitialized_fill.pass.cpp
index 95c45dd50541..3816a2528688 100644
--- a/test/std/utilities/memory/specialized.algorithms/uninitialized.fill/uninitialized_fill.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/uninitialized.fill/uninitialized_fill.pass.cpp
@@ -36,7 +36,7 @@ struct Nasty
     Nasty() : i_ ( counter_++ ) {}
     Nasty * operator &() const { return NULL; }
     int i_;
-    static int counter_; 
+    static int counter_;
 };
 
 int Nasty::counter_ = 0;
diff --git a/test/std/utilities/memory/storage.iterator/raw_storag_iterator.base.pass.cpp b/test/std/utilities/memory/storage.iterator/raw_storage_iterator.base.pass.cpp
index 27b620569b83..62a3be80d8b6 100644
--- a/test/std/utilities/memory/storage.iterator/raw_storag_iterator.base.pass.cpp
+++ b/test/std/utilities/memory/storage.iterator/raw_storage_iterator.base.pass.cpp
@@ -13,6 +13,8 @@
 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
+
 int A_constructed = 0;
 
 struct A
@@ -29,7 +31,7 @@ public:
 
 int main()
 {
-#if __cplusplus >= 201402L
+#if TEST_STD_VER >= 14
     typedef std::aligned_storage<3*sizeof(A), std::alignment_of<A>::value>::type
             Storage;
     Storage buffer;
diff --git a/test/std/utilities/memory/storage.iterator/raw_storag_iterator.pass.cpp b/test/std/utilities/memory/storage.iterator/raw_storage_iterator.pass.cpp
index 914802423ce7..914802423ce7 100644
--- a/test/std/utilities/memory/storage.iterator/raw_storag_iterator.pass.cpp
+++ b/test/std/utilities/memory/storage.iterator/raw_storage_iterator.pass.cpp
diff --git a/test/std/utilities/memory/unique.ptr/unique.ptr.create/make_unique.array.pass.cpp b/test/std/utilities/memory/unique.ptr/unique.ptr.create/make_unique.array.pass.cpp
index b2fb58f529f3..30b4ecb94e18 100644
--- a/test/std/utilities/memory/unique.ptr/unique.ptr.create/make_unique.array.pass.cpp
+++ b/test/std/utilities/memory/unique.ptr/unique.ptr.create/make_unique.array.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 #include <memory>
 #include <string>
 #include <cassert>
@@ -23,23 +24,21 @@ private:
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     {
     auto p1 = std::make_unique<int[]>(5);
     for ( int i = 0; i < 5; ++i )
         assert ( p1[i] == 0 );
     }
-    
+
     {
     auto p2 = std::make_unique<std::string[]>(5);
     for ( int i = 0; i < 5; ++i )
         assert ( p2[i].size () == 0 );
     }
-    
+
     {
     auto p3 = std::make_unique<foo[]>(7);
     for ( int i = 0; i < 7; ++i )
         assert ( p3[i].get () == 3 );
     }
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/utilities/memory/unique.ptr/unique.ptr.create/make_unique.array4.fail.cpp b/test/std/utilities/memory/unique.ptr/unique.ptr.create/make_unique.array4.fail.cpp
index 26eb59bbfd71..07aa659bd9b0 100644
--- a/test/std/utilities/memory/unique.ptr/unique.ptr.create/make_unique.array4.fail.cpp
+++ b/test/std/utilities/memory/unique.ptr/unique.ptr.create/make_unique.array4.fail.cpp
@@ -13,5 +13,5 @@
 
 int main()
 {
-    auto up4 = std::make_unique<int[5]>(11, 22, 33, 44, 55); // deleted 
+    auto up4 = std::make_unique<int[5]>(11, 22, 33, 44, 55); // deleted
 }
diff --git a/test/std/utilities/memory/unique.ptr/unique.ptr.create/make_unique.single.pass.cpp b/test/std/utilities/memory/unique.ptr/unique.ptr.create/make_unique.single.pass.cpp
index 7326ed226557..ace2e4fc7137 100644
--- a/test/std/utilities/memory/unique.ptr/unique.ptr.create/make_unique.single.pass.cpp
+++ b/test/std/utilities/memory/unique.ptr/unique.ptr.create/make_unique.single.pass.cpp
@@ -7,20 +7,20 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 #include <memory>
 #include <string>
 #include <cassert>
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     {
     std::unique_ptr<int> p1 = std::make_unique<int>(1);
     assert ( *p1 == 1 );
     p1 = std::make_unique<int> ();
     assert ( *p1 == 0 );
     }
-    
+
     {
     std::unique_ptr<std::string> p2 = std::make_unique<std::string> ( "Meow!" );
     assert ( *p2 == "Meow!" );
@@ -29,5 +29,4 @@ int main()
     p2 = std::make_unique<std::string> ( 6, 'z' );
     assert ( *p2 == "zzzzzz" );
     }
-#endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/test/std/utilities/memory/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/convert_ctor.pass.cpp b/test/std/utilities/memory/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/convert_ctor.pass.cpp
new file mode 100644
index 000000000000..a611b1a12f05
--- /dev/null
+++ b/test/std/utilities/memory/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/convert_ctor.pass.cpp
@@ -0,0 +1,27 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <memory>
+
+// default_delete[]
+
+// template <class U>
+//   default_delete(const default_delete<U[]>&);
+//
+// This constructor shall not participate in overload resolution unless
+//   U(*)[] is convertible to T(*)[].
+
+#include <memory>
+#include <cassert>
+
+int main()
+{
+    std::default_delete<int[]> d1;
+    std::default_delete<const int[]> d2 = d1;
+}
diff --git a/test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/pointer_deleter01.pass.cpp b/test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/pointer_deleter01.pass.cpp
index 2d62bccdce50..2b0b5f0d945d 100644
--- a/test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/pointer_deleter01.pass.cpp
+++ b/test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/pointer_deleter01.pass.cpp
@@ -40,4 +40,10 @@ int main()
     assert(s.get_deleter().state() == 0);
     }
     assert(A::count == 0);
+
+    { // LWG#2520 says that nullptr is a valid input as well as null
+    std::unique_ptr<A[], Deleter<A[]> > s1(NULL, Deleter<A[]>());
+    std::unique_ptr<A[], Deleter<A[]> > s2(nullptr, Deleter<A[]>());
+    }
+    assert(A::count == 0);
 }
diff --git a/test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/pointer_deleter02.pass.cpp b/test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/pointer_deleter02.pass.cpp
index 914076b50f42..a92fdbc1d2c4 100644
--- a/test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/pointer_deleter02.pass.cpp
+++ b/test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/pointer_deleter02.pass.cpp
@@ -55,4 +55,10 @@ int main()
     assert(s.get_deleter().state() == 5);
     }
     assert(A::count == 0);
+    {
+    Deleter d;
+    std::unique_ptr<A[], Deleter> s(nullptr, d);
+    assert(s.get() == nullptr);
+    assert(s.get_deleter().state() == 5);
+    }
 }
diff --git a/test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/pointer_deleter03.pass.cpp b/test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/pointer_deleter03.pass.cpp
index a6f535f38f08..dd27401731a6 100644
--- a/test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/pointer_deleter03.pass.cpp
+++ b/test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/pointer_deleter03.pass.cpp
@@ -57,4 +57,9 @@ int main()
     assert(s.get_deleter().state() == 6);
     }
     assert(A::count == 0);
+    {
+    Deleter d;
+    std::unique_ptr<A[], Deleter&> s(nullptr, d);
+    assert(s.get() == nullptr);
+    }
 }
diff --git a/test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/pointer_deleter04.pass.cpp b/test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/pointer_deleter04.pass.cpp
index a4c917c1af76..02f44d357561 100644
--- a/test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/pointer_deleter04.pass.cpp
+++ b/test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/pointer_deleter04.pass.cpp
@@ -55,4 +55,9 @@ int main()
     assert(s.get_deleter().state() == 5);
     }
     assert(A::count == 0);
+    {
+    Deleter d;
+    std::unique_ptr<A[], const Deleter&> s(nullptr, d);
+    assert(s.get() == nullptr);
+    }
 }
diff --git a/test/std/utilities/memory/unique.ptr/unique.ptr.single/pointer_type.pass.cpp b/test/std/utilities/memory/unique.ptr/unique.ptr.single/pointer_type.pass.cpp
index 8721062c6d02..380f2e100eb6 100644
--- a/test/std/utilities/memory/unique.ptr/unique.ptr.single/pointer_type.pass.cpp
+++ b/test/std/utilities/memory/unique.ptr/unique.ptr.single/pointer_type.pass.cpp
@@ -16,11 +16,22 @@
 #include <memory>
 #include <type_traits>
 
+#include "test_macros.h"
+
 struct Deleter
 {
     struct pointer {};
 };
 
+struct D2 {
+private:
+    typedef void pointer;
+};
+
+struct D3 {
+    static long pointer;
+};
+
 int main()
 {
     {
@@ -31,4 +42,14 @@ int main()
     typedef std::unique_ptr<int, Deleter> P;
     static_assert((std::is_same<P::pointer, Deleter::pointer>::value), "");
     }
+#if TEST_STD_VER >= 11
+    {
+    typedef std::unique_ptr<int, D2> P;
+    static_assert(std::is_same<P::pointer, int*>::value, "");
+    }
+    {
+    typedef std::unique_ptr<int, D3> P;
+    static_assert(std::is_same<P::pointer, int*>::value, "");
+    }
+#endif
 }
diff --git a/test/std/utilities/memory/unique.ptr/unique.ptr.special/swap.pass.cpp b/test/std/utilities/memory/unique.ptr/unique.ptr.special/swap.pass.cpp
index 44b746fbcfd8..c525137d4841 100644
--- a/test/std/utilities/memory/unique.ptr/unique.ptr.special/swap.pass.cpp
+++ b/test/std/utilities/memory/unique.ptr/unique.ptr.special/swap.pass.cpp
@@ -16,6 +16,7 @@
 #include <memory>
 #include <cassert>
 
+#include "test_macros.h"
 #include "../deleter.h"
 
 struct A
@@ -34,6 +35,16 @@ struct A
 
 int A::count = 0;
 
+template <class T>
+struct NonSwappableDeleter {
+  explicit NonSwappableDeleter(int) {}
+  NonSwappableDeleter& operator=(NonSwappableDeleter const&) { return *this; }
+  void operator()(T*) const {}
+private:
+  NonSwappableDeleter(NonSwappableDeleter const&);
+
+};
+
 int main()
 {
     {
@@ -74,4 +85,18 @@ int main()
     assert(A::count == 6);
     }
     assert(A::count == 0);
+#if TEST_STD_VER >= 11
+    {
+        // test that unique_ptr's specialized swap is disabled when the deleter
+        // is non-swappable. Instead we should pick up the generic swap(T, T)
+        // and perform 3 move constructions.
+        typedef NonSwappableDeleter<int> D;
+        D  d(42);
+        int x = 42;
+        int y = 43;
+        std::unique_ptr<int, D&> p(&x, d);
+        std::unique_ptr<int, D&> p2(&y, d);
+        std::swap(p, p2);
+    }
+#endif
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.enab/enable_shared_from_this.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.enab/enable_shared_from_this.pass.cpp
index 77af13fa90d1..b9f8ee0746c3 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.enab/enable_shared_from_this.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.enab/enable_shared_from_this.pass.cpp
@@ -18,11 +18,16 @@
 // public:
 //     shared_ptr<T> shared_from_this();
 //     shared_ptr<T const> shared_from_this() const;
+//     weak_ptr<T> weak_from_this() noexcept;                         // C++17
+//     weak_ptr<T const> weak_from_this() const noexecpt;             // C++17
 // };
 
 #include <memory>
 #include <cassert>
 
+#include "test_macros.h"
+#include "count_new.hpp"
+
 struct T
     : public std::enable_shared_from_this<T>
 {
@@ -32,12 +37,31 @@ struct Y : T {};
 
 struct Z : Y {};
 
+void nullDeleter(void*) {}
+
+struct Foo : virtual public std::enable_shared_from_this<Foo>
+{
+	virtual ~Foo() {}
+};
+
+struct Bar : public Foo {
+    Bar(int) {}
+};
+
+
 int main()
 {
     {  // https://llvm.org/bugs/show_bug.cgi?id=18843
     std::shared_ptr<T const> t1(new T);
     std::shared_ptr<T const> t2(std::make_shared<T>());
     }
+    { // https://llvm.org/bugs/show_bug.cgi?id=27115
+    int x = 42;
+    std::shared_ptr<Bar> t1(new Bar(42));
+    assert(t1->shared_from_this() == t1);
+    std::shared_ptr<Bar> t2(std::make_shared<Bar>(x));
+    assert(t2->shared_from_this() == t2);
+    }
     {
     std::shared_ptr<Y> p(new Z);
     std::shared_ptr<T> q = p->shared_from_this();
@@ -50,4 +74,89 @@ int main()
     assert(p == q);
     assert(!p.owner_before(q) && !q.owner_before(p)); // p and q share ownership
     }
+    // Test LWG issue 2529. Only reset '__weak_ptr_' when it's already expired.
+    // http://cplusplus.github.io/LWG/lwg-active.html#2529.
+    // Test two different ways:
+    // * Using 'weak_from_this().expired()' in C++17.
+    // * Using 'shared_from_this()' in all dialects.
+    {
+        assert(globalMemCounter.checkOutstandingNewEq(0));
+        T* ptr = new T;
+        std::shared_ptr<T> s(ptr);
+        {
+            // Don't re-initialize the "enabled_shared_from_this" base
+            // because it already references a non-expired shared_ptr.
+            std::shared_ptr<T> s2(ptr, &nullDeleter);
+        }
+#if TEST_STD_VER > 14
+        // The enabled_shared_from_this base should still be referencing
+        // the original shared_ptr.
+        assert(!ptr->weak_from_this().expired());
+#endif
+#ifndef TEST_HAS_NO_EXCEPTIONS
+        {
+            try {
+                std::shared_ptr<T> new_s = ptr->shared_from_this();
+                assert(new_s == s);
+            } catch (std::bad_weak_ptr const&) {
+                assert(false);
+            } catch (...) {
+                assert(false);
+            }
+        }
+#endif
+        s.reset();
+        assert(globalMemCounter.checkOutstandingNewEq(0));
+    }
+    // Test LWG issue 2529 again. This time check that an expired pointer
+    // is replaced.
+    {
+        assert(globalMemCounter.checkOutstandingNewEq(0));
+        T* ptr = new T;
+        std::weak_ptr<T> weak;
+        {
+            std::shared_ptr<T> s(ptr, &nullDeleter);
+            assert(ptr->shared_from_this() == s);
+            weak = s;
+            assert(!weak.expired());
+        }
+        assert(weak.expired());
+        weak.reset();
+
+#ifndef TEST_HAS_NO_EXCEPTIONS
+        try {
+            ptr->shared_from_this();
+            assert(false);
+        } catch (std::bad_weak_ptr const&) {
+        } catch (...) { assert(false); }
+#endif
+        {
+            std::shared_ptr<T> s2(ptr, &nullDeleter);
+            assert(ptr->shared_from_this() == s2);
+        }
+        delete ptr;
+        assert(globalMemCounter.checkOutstandingNewEq(0));
+    }
+    // Test weak_from_this_methods
+#if TEST_STD_VER > 14
+    {
+        T* ptr = new T;
+        const T* cptr = ptr;
+
+        static_assert(noexcept(ptr->weak_from_this()), "Operation must be noexcept");
+        static_assert(noexcept(cptr->weak_from_this()), "Operation must be noexcept");
+
+        std::weak_ptr<T> my_weak = ptr->weak_from_this();
+        assert(my_weak.expired());
+
+        std::weak_ptr<T const> my_const_weak = cptr->weak_from_this();
+        assert(my_const_weak.expired());
+
+        // Enable shared_from_this with ptr.
+        std::shared_ptr<T> sptr(ptr);
+        my_weak = ptr->weak_from_this();
+        assert(!my_weak.expired());
+        assert(my_weak.lock().get() == ptr);
+    }
+#endif
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong.pass.cpp
index 2d586e9c7fdd..3bad537e3431 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong.pass.cpp
@@ -23,12 +23,15 @@
 // atomic_compare_exchange_strong(shared_ptr<T>* p, shared_ptr<T>* v,
 //                                shared_ptr<T> w);
 
+// UNSUPPORTED: c++98, c++03
+
 #include <memory>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
-#if __has_feature(cxx_atomic)
     {
         std::shared_ptr<int> p(new int(4));
         std::shared_ptr<int> v(new int(3));
@@ -49,5 +52,4 @@ int main()
         assert(*v == 4);
         assert(*w == 2);
     }
-#endif
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong_explicit.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong_explicit.pass.cpp
index 34da04cc1810..5cc1234ad34e 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong_explicit.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong_explicit.pass.cpp
@@ -24,12 +24,15 @@
 //                                         shared_ptr<T> w, memory_order success,
 //                                         memory_order failure);
 
+// UNSUPPORTED: c++98, c++03
+
 #include <memory>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
-#if __has_feature(cxx_atomic)
     {
         std::shared_ptr<int> p(new int(4));
         std::shared_ptr<int> v(new int(3));
@@ -54,5 +57,4 @@ int main()
         assert(*v == 4);
         assert(*w == 2);
     }
-#endif
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak.pass.cpp
index 50b96e551fd3..a89c0dbd2207 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak.pass.cpp
@@ -23,12 +23,15 @@
 // atomic_compare_exchange_weak(shared_ptr<T>* p, shared_ptr<T>* v,
 //                              shared_ptr<T> w);
 
+// UNSUPPORTED: c++98, c++03
+
 #include <memory>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
-#if __has_feature(cxx_atomic)
     {
         std::shared_ptr<int> p(new int(4));
         std::shared_ptr<int> v(new int(3));
@@ -49,5 +52,4 @@ int main()
         assert(*v == 4);
         assert(*w == 2);
     }
-#endif
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak_explicit.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak_explicit.pass.cpp
index d304319d251d..821cea6868e4 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak_explicit.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak_explicit.pass.cpp
@@ -24,12 +24,15 @@
 //                                       shared_ptr<T> w, memory_order success,
 //                                       memory_order failure);
 
+// UNSUPPORTED: c++98, c++03
+
 #include <memory>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
-#if __has_feature(cxx_atomic)
     {
         std::shared_ptr<int> p(new int(4));
         std::shared_ptr<int> v(new int(3));
@@ -54,5 +57,4 @@ int main()
         assert(*v == 4);
         assert(*w == 2);
     }
-#endif
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange.pass.cpp
index 3b44c8ba9b33..66be756d54fd 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange.pass.cpp
@@ -22,12 +22,15 @@
 // shared_ptr<T>
 // atomic_exchange(shared_ptr<T>* p, shared_ptr<T> r)
 
+// UNSUPPORTED: c++98, c++03
+
 #include <memory>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
-#if __has_feature(cxx_atomic)
     {
         std::shared_ptr<int> p(new int(4));
         std::shared_ptr<int> r(new int(3));
@@ -35,5 +38,4 @@ int main()
         assert(*p == 3);
         assert(*r == 4);
     }
-#endif
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange_explicit.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange_explicit.pass.cpp
index 598a1b8da175..493ba7fcc94d 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange_explicit.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange_explicit.pass.cpp
@@ -22,12 +22,15 @@
 // shared_ptr<T>
 // atomic_exchange_explicit(shared_ptr<T>* p, shared_ptr<T> r)
 
+// UNSUPPORTED: c++98, c++03
+
 #include <memory>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
-#if __has_feature(cxx_atomic)
     {
         std::shared_ptr<int> p(new int(4));
         std::shared_ptr<int> r(new int(3));
@@ -35,5 +38,4 @@ int main()
         assert(*p == 3);
         assert(*r == 4);
     }
-#endif
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_is_lock_free.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_is_lock_free.pass.cpp
index e3ac84a4fa50..f72a0bb24285 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_is_lock_free.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_is_lock_free.pass.cpp
@@ -17,15 +17,17 @@
 // bool
 // atomic_is_lock_free(const shared_ptr<T>* p);
 
+// UNSUPPORTED: c++98, c++03
+
 #include <memory>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
-#if __has_feature(cxx_atomic)
     {
         const std::shared_ptr<int> p(new int(3));
         assert(std::atomic_is_lock_free(&p) == false);
     }
-#endif
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load.pass.cpp
index d4a39c878ac7..4820d05420a2 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load.pass.cpp
@@ -22,16 +22,18 @@
 // shared_ptr<T>
 // atomic_load(const shared_ptr<T>* p)
 
+// UNSUPPORTED: c++98, c++03
+
 #include <memory>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
-#if __has_feature(cxx_atomic)
     {
         std::shared_ptr<int> p(new int(3));
         std::shared_ptr<int> q = std::atomic_load(&p);
         assert(*q == *p);
     }
-#endif
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load_explicit.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load_explicit.pass.cpp
index af11dc8bc2c9..ef8dc822102f 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load_explicit.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load_explicit.pass.cpp
@@ -22,16 +22,18 @@
 // shared_ptr<T>
 // atomic_load_explicit(const shared_ptr<T>* p, memory_order mo)
 
+// UNSUPPORTED: c++98, c++03
+
 #include <memory>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
-#if __has_feature(cxx_atomic)
     {
         const std::shared_ptr<int> p(new int(3));
         std::shared_ptr<int> q = std::atomic_load_explicit(&p, std::memory_order_relaxed);
         assert(*q == *p);
     }
-#endif
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store.pass.cpp
index 7a85a9934ef0..a13a7d57ab96 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store.pass.cpp
@@ -22,17 +22,19 @@
 // void
 // atomic_store(shared_ptr<T>* p, shared_ptr<T> r)
 
+// UNSUPPORTED: c++98, c++03
+
 #include <memory>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
-#if __has_feature(cxx_atomic)
     {
         std::shared_ptr<int> p;
         std::shared_ptr<int> r(new int(3));
         std::atomic_store(&p, r);
         assert(*p == *r);
     }
-#endif
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store_explicit.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store_explicit.pass.cpp
index c81266c55fa4..6dfe3166c8c5 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store_explicit.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store_explicit.pass.cpp
@@ -22,17 +22,19 @@
 // void
 // atomic_store_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo)
 
+// UNSUPPORTED: c++98, c++03
+
 #include <memory>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
-#if __has_feature(cxx_atomic)
     {
         std::shared_ptr<int> p;
         std::shared_ptr<int> r(new int(3));
         std::atomic_store_explicit(&p, r, std::memory_order_seq_cst);
         assert(*p == *r);
     }
-#endif
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/test_deleter.h b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/test_deleter.h
index 0263061b3a84..bae1e013f571 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/test_deleter.h
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/test_deleter.h
@@ -52,7 +52,7 @@ public:
     void set_state(int i) {state_ = i;}
 
     void operator()(T* p) {assert(state_ >= 0); ++dealloc_count; delete p;}
-   
+
     test_deleter* operator&() const DELETE_FUNCTION;
 };
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/types.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/types.pass.cpp
index 8175312334f6..f44c05eb7c86 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/types.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/types.pass.cpp
@@ -13,14 +13,20 @@
 // {
 // public:
 //     typedef T element_type;
+//     typedef weak_ptr<T> weak_type; // C++17
 //     ...
 // };
 
 #include <memory>
 
+#include "test_macros.h"
+
 struct A;  // purposefully incomplete
 
 int main()
 {
     static_assert((std::is_same<std::shared_ptr<A>::element_type, A>::value), "");
+#if TEST_STD_VER > 14
+    static_assert((std::is_same<std::shared_ptr<A>::weak_type, std::weak_ptr<A>>::value), "");
+#endif
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/auto_ptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/auto_ptr.pass.cpp
index f17485108b92..f8fdb7a09478 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/auto_ptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/auto_ptr.pass.cpp
@@ -7,31 +7,18 @@
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <memory>
 
 // template<class Y> explicit shared_ptr(auto_ptr<Y>&& r);
 
-// UNSUPPORTED: sanitizer-new-delete
 
 #include <memory>
 #include <new>
 #include <cstdlib>
 #include <cassert>
 
-bool throw_next = false;
-
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    if (throw_next)
-        throw std::bad_alloc();
-    return std::malloc(s);
-}
-
-void  operator delete(void* p) throw()
-{
-    std::free(p);
-}
+#include "test_macros.h"
+#include "count_new.hpp"
 
 struct B
 {
@@ -59,47 +46,51 @@ int A::count = 0;
 int main()
 {
     {
-    std::auto_ptr<A> ptr(new A);
-    A* raw_ptr = ptr.get();
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    std::shared_ptr<B> p(std::move(ptr));
-#else
-    std::shared_ptr<B> p(ptr);
-#endif
-    assert(A::count == 1);
-    assert(B::count == 1);
-    assert(p.use_count() == 1);
-    assert(p.get() == raw_ptr);
-    assert(ptr.get() == 0);
-    }
-    assert(A::count == 0);
-    {
-    std::auto_ptr<A> ptr(new A);
-    A* raw_ptr = ptr.get();
-    throw_next = true;
-    try
-    {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+        std::auto_ptr<A> ptr(new A);
+        A* raw_ptr = ptr.get();
+#if TEST_STD_VER >= 11
         std::shared_ptr<B> p(std::move(ptr));
 #else
         std::shared_ptr<B> p(ptr);
 #endif
-        assert(false);
-    }
-    catch (...)
-    {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         assert(A::count == 1);
         assert(B::count == 1);
-        assert(ptr.get() == raw_ptr);
+        assert(p.use_count() == 1);
+        assert(p.get() == raw_ptr);
+        assert(ptr.get() == 0);
+    }
+    assert(A::count == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
+#if !defined(TEST_HAS_NO_EXCEPTIONS) && !defined(DISABLE_NEW_COUNT)
+    {
+        std::auto_ptr<A> ptr(new A);
+        A* raw_ptr = ptr.get();
+        globalMemCounter.throw_after = 0;
+        try
+        {
+#if TEST_STD_VER >= 11
+            std::shared_ptr<B> p(std::move(ptr));
 #else
-        // Without rvalue references, ptr got copied into
-        // the shared_ptr destructor and the copy was
-        // destroyed during unwinding.
-        assert(A::count == 0);
-        assert(B::count == 0);
+            std::shared_ptr<B> p(ptr);
 #endif
-    }
+            assert(false);
+        }
+        catch (...)
+        {
+#if TEST_STD_VER >= 11
+            assert(A::count == 1);
+            assert(B::count == 1);
+            assert(ptr.get() == raw_ptr);
+ #else
+            // Without rvalue references, ptr got copied into
+            // the shared_ptr destructor and the copy was
+            // destroyed during unwinding.
+            assert(A::count == 0);
+            assert(B::count == 0);
+#endif
+        }
     }
     assert(A::count == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
+#endif // !defined(TEST_HAS_NO_EXCEPTIONS) && !defined(DISABLE_NEW_COUNT)
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator.pass.cpp
index b67f31ee45a8..8a6cd0f352ff 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator.pass.cpp
@@ -65,7 +65,7 @@ int main()
     assert(test_deleter<A>::count == 0);
     assert(test_deleter<A>::dealloc_count == 1);
     test_deleter<A>::dealloc_count = 0;
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     // Test an allocator that returns class-type pointers
     {
     std::shared_ptr<A> p(nullptr, test_deleter<A>(1), min_allocator<void>());
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_throw.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_throw.pass.cpp
index 6a79a8ef60db..85fc5e930544 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_throw.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_throw.pass.cpp
@@ -8,18 +8,22 @@
 //===----------------------------------------------------------------------===//
 
 // XFAIL: libcpp-no-exceptions
+// UNSUPPORTED: sanitizer-new-delete
+
 // <memory>
 
 // shared_ptr
 
 // template<class D> shared_ptr(nullptr_t, D d);
 
-// UNSUPPORTED: sanitizer-new-delete
-
 #include <memory>
 #include <cassert>
 #include <new>
 #include <cstdlib>
+
+#include "test_macros.h"
+#include "count_new.hpp"
+
 #include "../test_deleter.h"
 
 struct A
@@ -33,23 +37,10 @@ struct A
 
 int A::count = 0;
 
-bool throw_next = false;
-
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    if (throw_next)
-        throw std::bad_alloc();
-    return std::malloc(s);
-}
-
-void  operator delete(void* p) throw()
-{
-    std::free(p);
-}
 
 int main()
 {
-    throw_next = true;
+    globalMemCounter.throw_after = 0;
     try
     {
         std::shared_ptr<A> p(nullptr, test_deleter<A>(3));
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator.pass.cpp
index 1a9c09cdb78c..b0facfc1a6eb 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator.pass.cpp
@@ -68,7 +68,7 @@ int main()
     assert(test_deleter<A>::count == 0);
     assert(test_deleter<A>::dealloc_count == 1);
     test_deleter<A>::dealloc_count = 0;
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     // Test an allocator that returns class-type pointers
     {
     A* ptr = new A;
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_throw.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_throw.pass.cpp
index 982313b07499..70af2964113d 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_throw.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_throw.pass.cpp
@@ -8,18 +8,20 @@
 //===----------------------------------------------------------------------===//
 
 // XFAIL: libcpp-no-exceptions
+// UNSUPPORTED: sanitizer-new-delete
+
 // <memory>
 
 // shared_ptr
 
 // template<class Y, class D> shared_ptr(Y* p, D d);
 
-// UNSUPPORTED: sanitizer-new-delete
-
 #include <memory>
 #include <cassert>
 #include <new>
 #include <cstdlib>
+
+#include "count_new.hpp"
 #include "../test_deleter.h"
 
 struct A
@@ -33,24 +35,10 @@ struct A
 
 int A::count = 0;
 
-bool throw_next = false;
-
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    if (throw_next)
-        throw std::bad_alloc();
-    return std::malloc(s);
-}
-
-void  operator delete(void* p) throw()
-{
-    std::free(p);
-}
-
 int main()
 {
     A* ptr = new A;
-    throw_next = true;
+    globalMemCounter.throw_after = 0;
     try
     {
         std::shared_ptr<A> p(ptr, test_deleter<A>(3));
@@ -62,4 +50,5 @@ int main()
         assert(test_deleter<A>::count == 0);
         assert(test_deleter<A>::dealloc_count == 1);
     }
+    assert(globalMemCounter.checkOutstandingNewEq(0));
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_throw.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_throw.pass.cpp
index 2e761d70bba0..2fa975eca833 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_throw.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_throw.pass.cpp
@@ -8,17 +8,20 @@
 //===----------------------------------------------------------------------===//
 
 // XFAIL: libcpp-no-exceptions
+// UNSUPPORTED: sanitizer-new-delete
+
 // <memory>
 
 // template<class Y> explicit shared_ptr(Y* p);
 
-// UNSUPPORTED: sanitizer-new-delete
 
 #include <memory>
 #include <new>
 #include <cstdlib>
 #include <cassert>
 
+#include "count_new.hpp"
+
 struct A
 {
     static int count;
@@ -30,26 +33,12 @@ struct A
 
 int A::count = 0;
 
-bool throw_next = false;
-
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    if (throw_next)
-        throw std::bad_alloc();
-    return std::malloc(s);
-}
-
-void  operator delete(void* p) throw()
-{
-    std::free(p);
-}
 
 int main()
 {
-    {
     A* ptr = new A;
-    throw_next = true;
     assert(A::count == 1);
+    globalMemCounter.throw_after = 0;
     try
     {
         std::shared_ptr<A> p(ptr);
@@ -59,5 +48,5 @@ int main()
     {
         assert(A::count == 0);
     }
-    }
+    assert(globalMemCounter.checkOutstandingNewEq(0));
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/unique_ptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/unique_ptr.pass.cpp
index c62fcd689320..5c424f5c7428 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/unique_ptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/unique_ptr.pass.cpp
@@ -8,30 +8,19 @@
 //===----------------------------------------------------------------------===//
 
 // XFAIL: libcpp-no-exceptions
+// UNSUPPORTED: sanitizer-new-delete
+
 // <memory>
 
 // template <class Y, class D> explicit shared_ptr(unique_ptr<Y, D>&&r);
 
-// UNSUPPORTED: sanitizer-new-delete
-
 #include <memory>
 #include <new>
 #include <cstdlib>
 #include <cassert>
 
-bool throw_next = false;
-
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    if (throw_next)
-        throw std::bad_alloc();
-    return std::malloc(s);
-}
-
-void  operator delete(void* p) throw()
-{
-    std::free(p);
-}
+#include "test_macros.h"
+#include "count_new.hpp"
 
 struct B
 {
@@ -65,52 +54,46 @@ void assert_deleter ( T * ) { assert(false); }
 int main()
 {
     {
-    std::unique_ptr<A> ptr(new A);
-    A* raw_ptr = ptr.get();
-    std::shared_ptr<B> p(std::move(ptr));
-    assert(A::count == 1);
-    assert(B::count == 1);
-    assert(p.use_count() == 1);
-    assert(p.get() == raw_ptr);
-    assert(ptr.get() == 0);
-    }
-    assert(A::count == 0);
-    {
-    std::unique_ptr<A> ptr(new A);
-    A* raw_ptr = ptr.get();
-    throw_next = true;
-    try
-    {
+        std::unique_ptr<A> ptr(new A);
+        A* raw_ptr = ptr.get();
         std::shared_ptr<B> p(std::move(ptr));
-        assert(false);
-    }
-    catch (...)
-    {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         assert(A::count == 1);
         assert(B::count == 1);
-        assert(ptr.get() == raw_ptr);
-#else
-        assert(A::count == 0);
-        assert(B::count == 0);
+        assert(p.use_count() == 1);
+        assert(p.get() == raw_ptr);
         assert(ptr.get() == 0);
-#endif
-    }
     }
     assert(A::count == 0);
-
-    // LWG 2399
     {
-    throw_next = false;
-    fn(std::unique_ptr<int>(new int));
+        std::unique_ptr<A> ptr(new A);
+        A* raw_ptr = ptr.get();
+        globalMemCounter.throw_after = 0;
+        try
+        {
+            std::shared_ptr<B> p(std::move(ptr));
+            assert(false);
+        }
+        catch (...)
+        {
+#if TEST_STD_VER >= 11
+            assert(A::count == 1);
+            assert(B::count == 1);
+            assert(ptr.get() == raw_ptr);
+#else
+            assert(A::count == 0);
+            assert(B::count == 0);
+            assert(ptr.get() == 0);
+#endif
+        }
     }
-
-#if __cplusplus >= 201402L
-    // LWG 2415
-    {
-    std::unique_ptr<int, void (*)(int*)> p(nullptr, assert_deleter<int>);
-    std::shared_ptr<int> p2(std::move(p)); // should not call deleter when going out of scope
+    assert(A::count == 0);
+    { // LWG 2399
+        fn(std::unique_ptr<int>(new int));
+    }
+#if TEST_STD_VER >= 14
+    { // LWG 2415
+        std::unique_ptr<int, void (*)(int*)> p(nullptr, assert_deleter<int>);
+        std::shared_ptr<int> p2(std::move(p)); // should not call deleter when going out of scope
     }
 #endif
-    
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared.pass.cpp
index aa77dab51515..3e4a99e981d4 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <memory>
 
 // shared_ptr
@@ -55,7 +57,6 @@ int main()
     }
     assert(A::count == 0);
     assert(test_allocator<A>::alloc_count == 0);
-#if __cplusplus >= 201103L
     {
     int i = 67;
     char c = 'e';
@@ -74,5 +75,4 @@ int main()
     assert(p->get_char() == 'f');
     }
     assert(A::count == 0);
-#endif
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared_no_variadics.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared_cxx03.pass.cpp
index 8dcd50e49411..527bbce1473e 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared_no_variadics.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared_cxx03.pass.cpp
@@ -14,7 +14,7 @@
 // template<class T, class A, class... Args>
 //    shared_ptr<T> allocate_shared(const A& a, Args&&... args);
 
-#define _LIBCPP_HAS_NO_VARIADICS
+
 #include <memory>
 #include <new>
 #include <cstdlib>
@@ -112,7 +112,7 @@ int main()
     assert(test_allocator<Two>::alloc_count == 0);
 
     test<bare_allocator<void> >();
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     test<min_allocator<void> >();
 #endif
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.volatile.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.volatile.pass.cpp
index 1045f9347b38..59cd3d248639 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.volatile.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.volatile.pass.cpp
@@ -34,7 +34,7 @@ void test(const T &t0)
     assert(*p0 == t0);
     assert(*p1 == t1);
     }
-    
+
     {
     volatile T t1 = t0;
     std::shared_ptr<volatile T> p0 = std::make_shared<volatile T>(t0);
@@ -50,7 +50,7 @@ void test(const T &t0)
     assert(*p0 == t0);
     assert(*p1 == t1);
     }
-    
+
 }
 
 int main()
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.ownerless/owner_less.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.ownerless/owner_less.pass.cpp
index bf1719c66ffa..142eba2d9647 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.ownerless/owner_less.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.ownerless/owner_less.pass.cpp
@@ -30,7 +30,7 @@
 //     bool operator()(shared_ptr<T> const&, weak_ptr<T> const&) const;
 //     bool operator()(weak_ptr<T> const&, shared_ptr<T> const&) const;
 // };
-// 
+//
 // Added in C++17
 // template<> struct owner_less<void>
 // {
@@ -42,7 +42,7 @@
 //         bool operator()(weak_ptr<T> const&, shared_ptr<U> const&) const;
 //     template<class T, class U>
 //         bool operator()(weak_ptr<T> const&, weak_ptr<U> const&) const;
-// 
+//
 //     typedef unspecified is_transparent;
 // };
 
@@ -113,7 +113,7 @@ int main()
     cmp(wp1, wp1);
     }
     {
-    // test heterogeneous lookups 
+    // test heterogeneous lookups
     std::set<std::shared_ptr<X>, std::owner_less<>> s;
     std::shared_ptr<void> vp;
     s.find(vp);
diff --git a/test/std/utilities/meta/meta.hel/bool_constant.pass.cpp b/test/std/utilities/meta/meta.help/bool_constant.pass.cpp
index 71110ea3bfb0..dcacf379b9ae 100644
--- a/test/std/utilities/meta/meta.hel/bool_constant.pass.cpp
+++ b/test/std/utilities/meta/meta.help/bool_constant.pass.cpp
@@ -14,9 +14,11 @@
 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
-#if __cplusplus > 201402L
+#if TEST_STD_VER > 14
     typedef std::bool_constant<true> _t;
     static_assert(_t::value, "");
     static_assert((std::is_same<_t::value_type, bool>::value), "");
diff --git a/test/std/utilities/meta/meta.hel/integral_constant.pass.cpp b/test/std/utilities/meta/meta.help/integral_constant.pass.cpp
index 335305a28236..335305a28236 100644
--- a/test/std/utilities/meta/meta.hel/integral_constant.pass.cpp
+++ b/test/std/utilities/meta/meta.help/integral_constant.pass.cpp
diff --git a/test/std/utilities/meta/meta.logical/conjunction.pass.cpp b/test/std/utilities/meta/meta.logical/conjunction.pass.cpp
index dce58ec23725..d8dd386e9347 100644
--- a/test/std/utilities/meta/meta.logical/conjunction.pass.cpp
+++ b/test/std/utilities/meta/meta.logical/conjunction.pass.cpp
@@ -11,7 +11,7 @@
 // type_traits
 
 // template<class... B> struct conjunction;                           // C++17
-// template<class... B> 
+// template<class... B>
 //   constexpr bool conjunction_v = conjunction<B...>::value;         // C++17
 
 #include <type_traits>
@@ -34,7 +34,7 @@ int main()
     static_assert (!std::conjunction<std::true_type,  std::false_type>::value, "" );
     static_assert (!std::conjunction<std::false_type, std::true_type >::value, "" );
     static_assert (!std::conjunction<std::false_type, std::false_type>::value, "" );
-    
+
     static_assert ( std::conjunction_v<std::true_type,  std::true_type >, "" );
     static_assert (!std::conjunction_v<std::true_type,  std::false_type>, "" );
     static_assert (!std::conjunction_v<std::false_type, std::true_type >, "" );
diff --git a/test/std/utilities/meta/meta.logical/disjunction.pass.cpp b/test/std/utilities/meta/meta.logical/disjunction.pass.cpp
index 13cd9341b99f..f5ba178d6483 100644
--- a/test/std/utilities/meta/meta.logical/disjunction.pass.cpp
+++ b/test/std/utilities/meta/meta.logical/disjunction.pass.cpp
@@ -11,7 +11,7 @@
 // type_traits
 
 // template<class... B> struct disjunction;                           // C++17
-// template<class... B> 
+// template<class... B>
 //   constexpr bool disjunction_v = disjunction<B...>::value;         // C++17
 
 #include <type_traits>
@@ -34,7 +34,7 @@ int main()
     static_assert ( std::disjunction<std::true_type,  std::false_type>::value, "" );
     static_assert ( std::disjunction<std::false_type, std::true_type >::value, "" );
     static_assert (!std::disjunction<std::false_type, std::false_type>::value, "" );
-    
+
     static_assert ( std::disjunction_v<std::true_type,  std::true_type >, "" );
     static_assert ( std::disjunction_v<std::true_type,  std::false_type>, "" );
     static_assert ( std::disjunction_v<std::false_type, std::true_type >, "" );
diff --git a/test/std/utilities/meta/meta.logical/negation.pass.cpp b/test/std/utilities/meta/meta.logical/negation.pass.cpp
index 76ff6c5b24db..7b4eb27a75e1 100644
--- a/test/std/utilities/meta/meta.logical/negation.pass.cpp
+++ b/test/std/utilities/meta/meta.logical/negation.pass.cpp
@@ -11,7 +11,7 @@
 // type_traits
 
 // template<class B> struct negation;                        // C++17
-// template<class B> 
+// template<class B>
 //   constexpr bool negation_v = negation<B>::value;         // C++17
 
 #include <type_traits>
diff --git a/test/std/utilities/meta/meta.rel/is_callable.pass.cpp b/test/std/utilities/meta/meta.rel/is_callable.pass.cpp
new file mode 100644
index 000000000000..4c85f440b0bf
--- /dev/null
+++ b/test/std/utilities/meta/meta.rel/is_callable.pass.cpp
@@ -0,0 +1,160 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11, c++14
+
+// type_traits
+
+// is_callable
+
+// Most testing of is_callable is done within the [meta.trans.other] result_of
+// tests.
+
+#include <type_traits>
+#include <functional>
+#include <memory>
+
+#include "test_macros.h"
+
+struct Tag {};
+struct DerFromTag : Tag {};
+
+struct Implicit {
+  Implicit(int) {}
+};
+
+struct Explicit {
+  explicit Explicit(int) {}
+};
+
+struct NotCallableWithInt {
+  int operator()(int) = delete;
+  int operator()(Tag) { return 42; }
+};
+
+int main()
+{
+    {
+        using Fn = int(Tag::*)(int);
+        using RFn = int(Tag::*)(int) &&;
+        // INVOKE bullet 1, 2 and 3
+        {
+            // Bullet 1
+            static_assert(std::is_callable<Fn(Tag&, int)>::value, "");
+            static_assert(std::is_callable<Fn(DerFromTag&, int)>::value, "");
+            static_assert(std::is_callable<RFn(Tag&&, int)>::value, "");
+            static_assert(!std::is_callable<RFn(Tag&, int)>::value, "");
+            static_assert(!std::is_callable<Fn(Tag&)>::value, "");
+            static_assert(!std::is_callable<Fn(Tag const&, int)>::value, "");
+        }
+        {
+            // Bullet 2
+            using T = std::reference_wrapper<Tag>;
+            using DT = std::reference_wrapper<DerFromTag>;
+            using CT = std::reference_wrapper<const Tag>;
+            static_assert(std::is_callable<Fn(T&, int)>::value, "");
+            static_assert(std::is_callable<Fn(DT&, int)>::value, "");
+            static_assert(std::is_callable<Fn(const T&, int)>::value, "");
+            static_assert(std::is_callable<Fn(T&&, int)>::value, "");
+            static_assert(!std::is_callable<Fn(CT&, int)>::value, "");
+            static_assert(!std::is_callable<RFn(T, int)>::value, "");
+        }
+        {
+            // Bullet 3
+            using T = Tag*;
+            using DT = DerFromTag*;
+            using CT = const Tag*;
+            using ST = std::unique_ptr<Tag>;
+            static_assert(std::is_callable<Fn(T&, int)>::value, "");
+            static_assert(std::is_callable<Fn(DT&, int)>::value, "");
+            static_assert(std::is_callable<Fn(const T&, int)>::value, "");
+            static_assert(std::is_callable<Fn(T&&, int)>::value, "");
+            static_assert(std::is_callable<Fn(ST, int)>::value, "");
+            static_assert(!std::is_callable<Fn(CT&, int)>::value, "");
+            static_assert(!std::is_callable<RFn(T, int)>::value, "");
+        }
+    }
+    {
+        // Bullets 4, 5 and 6
+        using Fn = int (Tag::*);
+        static_assert(!std::is_callable<Fn()>::value, "");
+        {
+            // Bullet 4
+            static_assert(std::is_callable<Fn(Tag&)>::value, "");
+            static_assert(std::is_callable<Fn(DerFromTag&)>::value, "");
+            static_assert(std::is_callable<Fn(Tag&&)>::value, "");
+            static_assert(std::is_callable<Fn(Tag const&)>::value, "");
+        }
+        {
+            // Bullet 5
+            using T = std::reference_wrapper<Tag>;
+            using DT = std::reference_wrapper<DerFromTag>;
+            using CT = std::reference_wrapper<const Tag>;
+            static_assert(std::is_callable<Fn(T&)>::value, "");
+            static_assert(std::is_callable<Fn(DT&)>::value, "");
+            static_assert(std::is_callable<Fn(const T&)>::value, "");
+            static_assert(std::is_callable<Fn(T&&)>::value, "");
+            static_assert(std::is_callable<Fn(CT&)>::value, "");
+        }
+        {
+            // Bullet 6
+            using T = Tag*;
+            using DT = DerFromTag*;
+            using CT = const Tag*;
+            using ST = std::unique_ptr<Tag>;
+            static_assert(std::is_callable<Fn(T&)>::value, "");
+            static_assert(std::is_callable<Fn(DT&)>::value, "");
+            static_assert(std::is_callable<Fn(const T&)>::value, "");
+            static_assert(std::is_callable<Fn(T&&)>::value, "");
+            static_assert(std::is_callable<Fn(ST)>::value, "");
+            static_assert(std::is_callable<Fn(CT&)>::value, "");
+        }
+    }
+    {
+        // INVOKE bullet 7
+        {
+            // Function pointer
+            using Fp = void(*)(Tag&, int);
+            static_assert(std::is_callable<Fp(Tag&, int)>::value, "");
+            static_assert(std::is_callable<Fp(DerFromTag&, int)>::value, "");
+            static_assert(!std::is_callable<Fp(const Tag&, int)>::value, "");
+            static_assert(!std::is_callable<Fp()>::value, "");
+            static_assert(!std::is_callable<Fp(Tag&)>::value, "");
+        }
+        {
+            // Function reference
+            using Fp = void(&)(Tag&, int);
+            static_assert(std::is_callable<Fp(Tag&, int)>::value, "");
+            static_assert(std::is_callable<Fp(DerFromTag&, int)>::value, "");
+            static_assert(!std::is_callable<Fp(const Tag&, int)>::value, "");
+            static_assert(!std::is_callable<Fp()>::value, "");
+            static_assert(!std::is_callable<Fp(Tag&)>::value, "");
+        }
+        {
+            // Function object
+            using Fn = NotCallableWithInt;
+            static_assert(std::is_callable<Fn(Tag)>::value, "");
+            static_assert(!std::is_callable<Fn(int)>::value, "");
+        }
+    }
+    {
+        // Check that the conversion to the return type is properly checked
+        using Fn = int(*)();
+        static_assert(std::is_callable<Fn(), Implicit>::value, "");
+        static_assert(std::is_callable<Fn(), double>::value, "");
+        static_assert(std::is_callable<Fn(), const volatile void>::value, "");
+        static_assert(!std::is_callable<Fn(), Explicit>::value, "");
+    }
+    {
+        // Check for is_callable_v
+        using Fn = void(*)();
+        static_assert(std::is_callable_v<Fn()>, "");
+        static_assert(!std::is_callable_v<Fn(int)>, "");
+    }
+}
diff --git a/test/std/utilities/meta/meta.rel/is_convertible.pass.cpp b/test/std/utilities/meta/meta.rel/is_convertible.pass.cpp
index 1681c39972d2..552c16075da7 100644
--- a/test/std/utilities/meta/meta.rel/is_convertible.pass.cpp
+++ b/test/std/utilities/meta/meta.rel/is_convertible.pass.cpp
@@ -12,7 +12,6 @@
 // is_convertible
 
 #include <type_traits>
-
 #include "test_macros.h"
 
 template <class T, class U>
@@ -46,12 +45,22 @@ void test_is_not_convertible()
 }
 
 typedef void Function();
+typedef void ConstFunction() const;
 typedef char Array[1];
 
+struct StringType {
+  StringType(const char*) {}
+};
+
 class NonCopyable {
   NonCopyable(NonCopyable&);
 };
 
+template <typename T>
+class CannotInstantiate {
+  enum { X = T::ThisExpressionWillBlowUp };
+};
+
 int main()
 {
     // void
@@ -64,12 +73,19 @@ int main()
     test_is_not_convertible<void,char> ();
     test_is_not_convertible<void,char&> ();
     test_is_not_convertible<void,char*> ();
+    test_is_not_convertible<char, void>();
 
     // Function
     test_is_not_convertible<Function, void> ();
     test_is_not_convertible<Function, Function> ();
     test_is_convertible<Function, Function&> ();
     test_is_convertible<Function, Function*> ();
+    test_is_convertible<Function, Function*const> ();
+
+#if TEST_STD_VER >= 11
+    static_assert(( std::is_convertible<Function, Function&&>::value), "");
+#endif
+
     test_is_not_convertible<Function, Array> ();
     test_is_not_convertible<Function, Array&> ();
     test_is_not_convertible<Function, char> ();
@@ -100,6 +116,16 @@ int main()
     test_is_not_convertible<Function*, char&> ();
     test_is_not_convertible<Function*, char*> ();
 
+    // Non-referencable function type
+    static_assert((!std::is_convertible<ConstFunction, Function>::value), "");
+    static_assert((!std::is_convertible<ConstFunction, Function*>::value), "");
+    static_assert((!std::is_convertible<ConstFunction, Function&>::value), "");
+    static_assert((!std::is_convertible<ConstFunction, Function>::value), "");
+    static_assert((!std::is_convertible<Function*, ConstFunction>::value), "");
+    static_assert((!std::is_convertible<Function&, ConstFunction>::value), "");
+    static_assert((!std::is_convertible<ConstFunction, ConstFunction>::value), "");
+    static_assert((!std::is_convertible<ConstFunction, void>::value), "");
+
     // Array
     test_is_not_convertible<Array, void> ();
     test_is_not_convertible<Array, Function> ();
@@ -109,17 +135,37 @@ int main()
 
     static_assert((!std::is_convertible<Array, Array&>::value), "");
     static_assert(( std::is_convertible<Array, const Array&>::value), "");
+    static_assert((!std::is_convertible<Array, const volatile Array&>::value), "");
+
     static_assert((!std::is_convertible<const Array, Array&>::value), "");
     static_assert(( std::is_convertible<const Array, const Array&>::value), "");
+    static_assert((!std::is_convertible<Array, volatile Array&>::value), "");
+    static_assert((!std::is_convertible<Array, const volatile Array&>::value), "");
+
+#if TEST_STD_VER >= 11
+    static_assert(( std::is_convertible<Array, Array&&>::value), "");
+    static_assert(( std::is_convertible<Array, const Array&&>::value), "");
+    static_assert(( std::is_convertible<Array, volatile Array&&>::value), "");
+    static_assert(( std::is_convertible<Array, const volatile Array&&>::value), "");
+    static_assert(( std::is_convertible<const Array, const Array&&>::value), "");
+    static_assert((!std::is_convertible<Array&, Array&&>::value), "");
+    static_assert((!std::is_convertible<Array&&, Array&>::value), "");
+#endif
 
     test_is_not_convertible<Array, char> ();
     test_is_not_convertible<Array, char&> ();
 
     static_assert(( std::is_convertible<Array, char*>::value), "");
     static_assert(( std::is_convertible<Array, const char*>::value), "");
+    static_assert(( std::is_convertible<Array, char* const>::value), "");
+    static_assert(( std::is_convertible<Array, char* const volatile>::value), "");
+
     static_assert((!std::is_convertible<const Array, char*>::value), "");
     static_assert(( std::is_convertible<const Array, const char*>::value), "");
 
+    static_assert((!std::is_convertible<char[42][42], char*>::value), "");
+    static_assert((!std::is_convertible<char[][1], char*>::value), "");
+
     // Array&
     test_is_not_convertible<Array&, void> ();
     test_is_not_convertible<Array&, Function> ();
@@ -140,6 +186,9 @@ int main()
     static_assert((!std::is_convertible<const Array&, char*>::value), "");
     static_assert(( std::is_convertible<const Array&, const char*>::value), "");
 
+    static_assert((std::is_convertible<Array, StringType>::value), "");
+    static_assert((std::is_convertible<char(&)[], StringType>::value), "");
+
     // char
     test_is_not_convertible<char, void> ();
     test_is_not_convertible<char, Function> ();
@@ -149,7 +198,7 @@ int main()
     test_is_not_convertible<char, Array&> ();
 
     test_is_convertible<char, char> ();
-    
+
     static_assert((!std::is_convertible<char, char&>::value), "");
     static_assert(( std::is_convertible<char, const char&>::value), "");
     static_assert((!std::is_convertible<const char, char&>::value), "");
@@ -166,7 +215,7 @@ int main()
     test_is_not_convertible<char&, Array&> ();
 
     test_is_convertible<char&, char> ();
-    
+
     static_assert(( std::is_convertible<char&, char&>::value), "");
     static_assert(( std::is_convertible<char&, const char&>::value), "");
     static_assert((!std::is_convertible<const char&, char&>::value), "");
@@ -184,7 +233,7 @@ int main()
 
     test_is_not_convertible<char*, char> ();
     test_is_not_convertible<char*, char&> ();
-    
+
     static_assert(( std::is_convertible<char*, char*>::value), "");
     static_assert(( std::is_convertible<char*, const char*>::value), "");
     static_assert((!std::is_convertible<const char*, char*>::value), "");
@@ -202,8 +251,11 @@ int main()
     static_assert((!std::is_convertible<const NonCopyable&, NonCopyable&>::value), "");
 // This test requires Access control SFINAE which we only have in C++11 or when
 // we are using the compiler builtin for is_convertible.
-#if __cplusplus >= 201103L || !defined(_LIBCPP_USE_IS_CONVERTIBLE_FALLBACK)
+#if TEST_STD_VER >= 11 || !defined(_LIBCPP_USE_IS_CONVERTIBLE_FALLBACK)
     test_is_not_convertible<NonCopyable&, NonCopyable>();
 #endif
 
+    // Ensure that CannotInstantiate is not instantiated by is_convertible when it is not needed.
+    // For example CannotInstantiate is instatiated as a part of ADL lookup for arguments of type CannotInstantiate*.
+    static_assert((std::is_convertible<CannotInstantiate<int>*, CannotInstantiate<int>*>::value), "");
 }
diff --git a/test/std/utilities/meta/meta.rel/is_nothrow_callable.pass.cpp b/test/std/utilities/meta/meta.rel/is_nothrow_callable.pass.cpp
new file mode 100644
index 000000000000..eefa6d1f22b1
--- /dev/null
+++ b/test/std/utilities/meta/meta.rel/is_nothrow_callable.pass.cpp
@@ -0,0 +1,115 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11, c++14
+
+// type_traits
+
+// is_nothrow_callable
+
+#include <type_traits>
+#include <functional>
+
+#include "test_macros.h"
+
+struct Tag {};
+
+struct Implicit {
+  Implicit(int) noexcept {}
+};
+
+struct ThrowsImplicit {
+  ThrowsImplicit(int) {}
+};
+
+struct Explicit {
+  explicit Explicit(int) noexcept {}
+};
+
+template <bool IsNoexcept, class Ret, class ...Args>
+struct CallObject {
+  Ret operator()(Args&&...) const noexcept(IsNoexcept);
+};
+
+template <class Fn>
+constexpr bool throws_callable() {
+    return std::is_callable<Fn>::value &&
+        !std::is_nothrow_callable<Fn>::value;
+}
+
+template <class Fn, class Ret>
+constexpr bool throws_callable() {
+    return std::is_callable<Fn, Ret>::value &&
+        !std::is_nothrow_callable<Fn, Ret>::value;
+}
+
+// FIXME(EricWF) Don't test the where noexcept is *not* part of the type system
+// once implementations have caught up.
+void test_noexcept_function_pointers()
+{
+    struct Dummy { void foo() noexcept {} static void bar() noexcept {} };
+#if !defined(__cpp_noexcept_function_type)
+    {
+        // Check that PMF's and function pointers *work*. is_nothrow_callable will always
+        // return false because 'noexcept' is not part of the function type.
+        static_assert(throws_callable<decltype(&Dummy::foo)(Dummy&)>(), "");
+        static_assert(throws_callable<decltype(&Dummy::bar)()>(), "");
+    }
+#else
+    {
+        // Check that PMF's and function pointers actually work and that
+        // is_nothrow_callable returns true for noexcept PMF's and function
+        // pointers.
+        static_assert(std::is_nothrow_callable<decltype(&Dummy::foo)(Dummy&)>::value, "");
+        static_assert(std::is_nothrow_callable<decltype(&Dummy::bar)()>::value, "");
+    }
+#endif
+}
+
+int main()
+{
+    {
+        // Check that the conversion to the return type is properly checked
+        using Fn = CallObject<true, int>;
+        static_assert(std::is_nothrow_callable<Fn(), Implicit>::value, "");
+        static_assert(std::is_nothrow_callable<Fn(), double>::value, "");
+        static_assert(std::is_nothrow_callable<Fn(), const volatile void>::value, "");
+        static_assert(throws_callable<Fn(), ThrowsImplicit>(), "");
+        static_assert(!std::is_nothrow_callable<Fn(), Explicit>(), "");
+    }
+    {
+        // Check that the conversion to the parameters is properly checked
+        using Fn = CallObject<true, void, const Implicit&, const ThrowsImplicit&>;
+        static_assert(std::is_nothrow_callable<Fn(Implicit&, ThrowsImplicit&)>::value, "");
+        static_assert(std::is_nothrow_callable<Fn(int, ThrowsImplicit&)>::value, "");
+        static_assert(throws_callable<Fn(int, int)>(), "");
+        static_assert(!std::is_nothrow_callable<Fn()>::value, "");
+    }
+    {
+        // Check that the noexcept-ness of function objects is checked.
+        using Fn = CallObject<true, void>;
+        using Fn2 = CallObject<false, void>;
+        static_assert(std::is_nothrow_callable<Fn()>::value, "");
+        static_assert(throws_callable<Fn2()>(), "");
+    }
+    {
+        // Check that PMD derefs are noexcept
+        using Fn = int (Tag::*);
+        static_assert(std::is_nothrow_callable<Fn(Tag&)>::value, "");
+        static_assert(std::is_nothrow_callable<Fn(Tag&), Implicit>::value, "");
+        static_assert(throws_callable<Fn(Tag&), ThrowsImplicit>(), "");
+    }
+    {
+        // Check for is_nothrow_callable_v
+        using Fn = CallObject<true, int>;
+        static_assert(std::is_nothrow_callable_v<Fn()>, "");
+        static_assert(!std::is_nothrow_callable_v<Fn(int)>, "");
+    }
+    test_noexcept_function_pointers();
+}
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_storage.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_storage.pass.cpp
index a53bed984c5e..079661d0c174 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_storage.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_storage.pass.cpp
@@ -164,7 +164,7 @@ int main()
     // Use alignof(std::max_align_t) below to find the max alignment instead of
     // hardcoding it, because it's different on different platforms.
     // (For example 8 on arm and 16 on x86.)
-#if __cplusplus < 201103L
+#if TEST_STD_VER < 11
 #define alignof __alignof__
 #endif
     {
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/enable_if2.fail.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/enable_if2.fail.cpp
index 8ce894578c4f..8c9b42d60f30 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/enable_if2.fail.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/enable_if2.fail.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // type_traits
 
 // enable_if
@@ -15,9 +16,5 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     typedef std::enable_if_t<false> A;
-#else
-    static_assert ( false, "" );
-#endif
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/result_of.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/result_of.pass.cpp
index 5a925bb34b26..fc01b22c36ab 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/result_of.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/result_of.pass.cpp
@@ -13,6 +13,7 @@
 
 #include <type_traits>
 #include <memory>
+#include <cassert>
 #include "test_macros.h"
 
 struct S
@@ -25,6 +26,11 @@ struct S
     double const volatile& operator()(char, int&) const volatile;
 };
 
+
+struct SD : public S { };
+
+struct NotDerived {};
+
 template <class Tp>
 struct Voider {
     typedef void type;
@@ -39,6 +45,10 @@ struct HasType<T, typename Voider<typename T::type>::type> : std::true_type {};
 template <class T, class U>
 void test_result_of()
 {
+#if TEST_STD_VER > 14
+    static_assert(std::is_callable<T>::value, "");
+    static_assert(std::is_callable<T, U>::value, "");
+#endif
     static_assert((std::is_same<typename std::result_of<T>::type, U>::value), "");
 }
 
@@ -48,10 +58,14 @@ void test_no_result()
 #if TEST_STD_VER >= 11
     static_assert((!HasType<std::result_of<T> >::value), "");
 #endif
+#if TEST_STD_VER > 14
+    static_assert(std::is_callable<T>::value == false, "");
+#endif
 }
 
 int main()
 {
+    typedef NotDerived ND;
     { // functor object
     test_result_of<S(int), short> ();
     test_result_of<S&(unsigned char, int&), double> ();
@@ -90,32 +104,64 @@ int main()
     typedef int         (S::*PMS0)();
     typedef int*        (S::*PMS1)(long);
     typedef int&        (S::*PMS2)(long, int);
-    test_result_of<PMS0(               S),   int> ();
-    test_result_of<PMS0(               S&),  int> ();
-    test_result_of<PMS0(               S*),  int> ();
-    test_result_of<PMS0(               S*&), int> ();
-    test_result_of<PMS0(std::unique_ptr<S>), int> ();
+    test_result_of<PMS0(                             S),   int> ();
+    test_result_of<PMS0(                             S&),  int> ();
+    test_result_of<PMS0(                             S*),  int> ();
+    test_result_of<PMS0(                             S*&), int> ();
+    test_result_of<PMS0(      std::reference_wrapper<S>),  int> ();
+    test_result_of<PMS0(const std::reference_wrapper<S>&), int> ();
+    test_result_of<PMS0(      std::reference_wrapper<SD>),  int> ();
+    test_result_of<PMS0(const std::reference_wrapper<SD>&), int> ();
+    test_result_of<PMS0(std::unique_ptr<S>),  int> ();
+    test_result_of<PMS0(std::unique_ptr<SD>), int> ();
     test_no_result<PMS0(const          S&)>();
     test_no_result<PMS0(volatile       S&)>();
     test_no_result<PMS0(const volatile S&)>();
+    test_no_result<PMS0(ND &                           )>();
+    test_no_result<PMS0(const ND&                      )>();
+    test_no_result<PMS0(std::unique_ptr<S const>       )>();
+    test_no_result<PMS0(std::reference_wrapper<S const>)>();
+    test_no_result<PMS0(std::reference_wrapper<ND>     )>();
+    test_no_result<PMS0(std::unique_ptr<ND>            )>();
 
-    test_result_of<PMS1(               S,   int), int*> ();
-    test_result_of<PMS1(               S&,  int), int*> ();
-    test_result_of<PMS1(               S*,  int), int*> ();
-    test_result_of<PMS1(               S*&, int), int*> ();
-    test_result_of<PMS1(std::unique_ptr<S>, int), int*> ();
+    test_result_of<PMS1(                             S,   int), int*> ();
+    test_result_of<PMS1(                             S&,  int), int*> ();
+    test_result_of<PMS1(                             S*,  int), int*> ();
+    test_result_of<PMS1(                             S*&, int), int*> ();
+    test_result_of<PMS1(std::unique_ptr<S>,               int), int*> ();
+    test_result_of<PMS1(std::unique_ptr<SD>,              int), int*> ();
+    test_result_of<PMS1(std::reference_wrapper<S>,        int), int*> ();
+    test_result_of<PMS1(const std::reference_wrapper<S>&, int), int*> ();
+    test_result_of<PMS1(std::reference_wrapper<SD>,        int), int*> ();
+    test_result_of<PMS1(const std::reference_wrapper<SD>&, int), int*> ();
     test_no_result<PMS1(const          S&, int)>();
     test_no_result<PMS1(volatile       S&, int)>();
     test_no_result<PMS1(const volatile S&, int)>();
+    test_no_result<PMS1(ND &,                            int)>();
+    test_no_result<PMS1(const ND&,                       int)>();
+    test_no_result<PMS1(std::unique_ptr<S const>,        int)>();
+    test_no_result<PMS1(std::reference_wrapper<S const>, int)>();
+    test_no_result<PMS1(std::reference_wrapper<ND>,      int)>();
+    test_no_result<PMS1(std::unique_ptr<ND>,             int)>();
 
     test_result_of<PMS2(               S,   int, int), int&> ();
     test_result_of<PMS2(               S&,  int, int), int&> ();
     test_result_of<PMS2(               S*,  int, int), int&> ();
     test_result_of<PMS2(               S*&, int, int), int&> ();
     test_result_of<PMS2(std::unique_ptr<S>, int, int), int&> ();
+    test_result_of<PMS2(std::unique_ptr<SD>, int, int), int&> ();
+    test_result_of<PMS2(std::reference_wrapper<S>,         int, int), int&> ();
+    test_result_of<PMS2(const std::reference_wrapper<S>&,  int, int), int&> ();
+    test_result_of<PMS2(std::reference_wrapper<SD>,        int, int), int&> ();
+    test_result_of<PMS2(const std::reference_wrapper<SD>&, int, int), int&> ();
     test_no_result<PMS2(const          S&, int, int)>();
     test_no_result<PMS2(volatile       S&, int, int)>();
     test_no_result<PMS2(const volatile S&, int, int)>();
+    test_no_result<PMS2(std::unique_ptr<S const>,   int, int)>();
+    test_no_result<PMS2(std::reference_wrapper<S const>, int, int)>();
+    test_no_result<PMS2(const ND&,                  int, int)>();
+    test_no_result<PMS2(std::reference_wrapper<ND>, int, int)>();
+    test_no_result<PMS2(std::unique_ptr<ND>,        int, int)>();
 
     typedef int        (S::*PMS0C)() const;
     typedef int*       (S::*PMS1C)(long) const;
@@ -128,6 +174,15 @@ int main()
     test_result_of<PMS0C(               S*&), int> ();
     test_result_of<PMS0C(const          S*&), int> ();
     test_result_of<PMS0C(std::unique_ptr<S>), int> ();
+    test_result_of<PMS0C(std::unique_ptr<SD>), int> ();
+    test_result_of<PMS0C(std::reference_wrapper<S>              ), int> ();
+    test_result_of<PMS0C(std::reference_wrapper<const S>        ), int> ();
+    test_result_of<PMS0C(const std::reference_wrapper<S> &      ), int> ();
+    test_result_of<PMS0C(const std::reference_wrapper<const S> &), int> ();
+    test_result_of<PMS0C(std::reference_wrapper<SD>             ), int> ();
+    test_result_of<PMS0C(std::reference_wrapper<const SD>       ), int> ();
+    test_result_of<PMS0C(const std::reference_wrapper<SD> &     ), int> ();
+    test_result_of<PMS0C(const std::reference_wrapper<const SD> &), int> ();
     test_no_result<PMS0C(volatile       S&)>();
     test_no_result<PMS0C(const volatile S&)>();
 
@@ -248,5 +303,16 @@ int main()
     test_result_of<PMD(volatile S*), volatile char&> ();
     test_result_of<PMD(const volatile S&), const volatile char&> ();
     test_result_of<PMD(const volatile S*), const volatile char&> ();
+    test_result_of<PMD(SD&), char &>();
+    test_result_of<PMD(SD const&), const char&>();
+    test_result_of<PMD(SD*), char&>();
+    test_result_of<PMD(const SD*), const char&>();
+    test_result_of<PMD(std::unique_ptr<S>), char &>();
+    test_result_of<PMD(std::unique_ptr<S const>), const char&>();
+#if TEST_STD_VER >= 11
+    test_result_of<PMD(std::reference_wrapper<S>), char&>();
+    test_result_of<PMD(std::reference_wrapper<S const>), const char&>();
+#endif
+    test_no_result<PMD(ND&)>();
     }
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/result_of11.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/result_of11.pass.cpp
index 6996cddc08b9..8cb5853bbc6d 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/result_of11.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/result_of11.pass.cpp
@@ -14,6 +14,8 @@
 // result_of<Fn(ArgTypes...)>
 
 #include <type_traits>
+#include <memory>
+#include <utility>
 #include "test_macros.h"
 
 struct wat
@@ -23,6 +25,8 @@ struct wat
 };
 
 struct F {};
+struct FD : public F {};
+struct NotDerived {};
 
 template <class T, class U>
 void test_result_of_imp()
@@ -31,10 +35,15 @@ void test_result_of_imp()
 #if TEST_STD_VER > 11
     static_assert((std::is_same<std::result_of_t<T>, U>::value), "");
 #endif
+#if TEST_STD_VER > 14
+    static_assert(std::is_callable<T>::value, "");
+    static_assert(std::is_callable<T, U>::value, "");
+#endif
 }
 
 int main()
 {
+    typedef NotDerived ND;
     {
     typedef char F::*PMD;
     test_result_of_imp<PMD(F                &), char                &>();
@@ -51,6 +60,31 @@ int main()
     test_result_of_imp<PMD(F const          ), char &&>();
     test_result_of_imp<PMD(F volatile       ), char &&>();
     test_result_of_imp<PMD(F const volatile ), char &&>();
+
+    test_result_of_imp<PMD(FD                &), char                &>();
+    test_result_of_imp<PMD(FD const          &), char const          &>();
+    test_result_of_imp<PMD(FD volatile       &), char volatile       &>();
+    test_result_of_imp<PMD(FD const volatile &), char const volatile &>();
+
+    test_result_of_imp<PMD(FD                &&), char                &&>();
+    test_result_of_imp<PMD(FD const          &&), char const          &&>();
+    test_result_of_imp<PMD(FD volatile       &&), char volatile       &&>();
+    test_result_of_imp<PMD(FD const volatile &&), char const volatile &&>();
+
+    test_result_of_imp<PMD(FD                ), char &&>();
+    test_result_of_imp<PMD(FD const          ), char &&>();
+    test_result_of_imp<PMD(FD volatile       ), char &&>();
+    test_result_of_imp<PMD(FD const volatile ), char &&>();
+
+    test_result_of_imp<PMD(std::unique_ptr<F>),        char &>();
+    test_result_of_imp<PMD(std::unique_ptr<F const>),  const char &>();
+    test_result_of_imp<PMD(std::unique_ptr<FD>),       char &>();
+    test_result_of_imp<PMD(std::unique_ptr<FD const>), const char &>();
+
+    test_result_of_imp<PMD(std::reference_wrapper<F>),        char &>();
+    test_result_of_imp<PMD(std::reference_wrapper<F const>),  const char &>();
+    test_result_of_imp<PMD(std::reference_wrapper<FD>),       char &>();
+    test_result_of_imp<PMD(std::reference_wrapper<FD const>), const char &>();
     }
     {
     test_result_of_imp<int (F::* (F       &)) ()                &, int> ();
@@ -83,6 +117,42 @@ int main()
     test_result_of_imp<int (F::* (F volatile )) () const volatile &&, int> ();
     test_result_of_imp<int (F::* (F const volatile )) () const volatile &&, int> ();
     }
+    {
+    test_result_of_imp<int (F::* (FD       &)) ()                &, int> ();
+    test_result_of_imp<int (F::* (FD       &)) () const          &, int> ();
+    test_result_of_imp<int (F::* (FD       &)) () volatile       &, int> ();
+    test_result_of_imp<int (F::* (FD       &)) () const volatile &, int> ();
+    test_result_of_imp<int (F::* (FD const &)) () const          &, int> ();
+    test_result_of_imp<int (F::* (FD const &)) () const volatile &, int> ();
+    test_result_of_imp<int (F::* (FD volatile &)) () volatile       &, int> ();
+    test_result_of_imp<int (F::* (FD volatile &)) () const volatile &, int> ();
+    test_result_of_imp<int (F::* (FD const volatile &)) () const volatile &, int> ();
+
+    test_result_of_imp<int (F::* (FD       &&)) ()                &&, int> ();
+    test_result_of_imp<int (F::* (FD       &&)) () const          &&, int> ();
+    test_result_of_imp<int (F::* (FD       &&)) () volatile       &&, int> ();
+    test_result_of_imp<int (F::* (FD       &&)) () const volatile &&, int> ();
+    test_result_of_imp<int (F::* (FD const &&)) () const          &&, int> ();
+    test_result_of_imp<int (F::* (FD const &&)) () const volatile &&, int> ();
+    test_result_of_imp<int (F::* (FD volatile &&)) () volatile       &&, int> ();
+    test_result_of_imp<int (F::* (FD volatile &&)) () const volatile &&, int> ();
+    test_result_of_imp<int (F::* (FD const volatile &&)) () const volatile &&, int> ();
 
+    test_result_of_imp<int (F::* (FD       )) ()                &&, int> ();
+    test_result_of_imp<int (F::* (FD       )) () const          &&, int> ();
+    test_result_of_imp<int (F::* (FD       )) () volatile       &&, int> ();
+    test_result_of_imp<int (F::* (FD       )) () const volatile &&, int> ();
+    test_result_of_imp<int (F::* (FD const )) () const          &&, int> ();
+    test_result_of_imp<int (F::* (FD const )) () const volatile &&, int> ();
+    test_result_of_imp<int (F::* (FD volatile )) () volatile       &&, int> ();
+    test_result_of_imp<int (F::* (FD volatile )) () const volatile &&, int> ();
+    test_result_of_imp<int (F::* (FD const volatile )) () const volatile &&, int> ();
+    }
+    {
+    test_result_of_imp<int (F::* (std::reference_wrapper<F>))       (),       int>();
+    test_result_of_imp<int (F::* (std::reference_wrapper<const F>)) () const, int>();
+    test_result_of_imp<int (F::* (std::unique_ptr<F>       ))       (),       int>();
+    test_result_of_imp<int (F::* (std::unique_ptr<const F> ))       () const, int>();
+    }
     test_result_of_imp<decltype(&wat::foo)(wat), void>();
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/underlying_type.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/underlying_type.pass.cpp
index 728062b70684..1d7b23c19222 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/underlying_type.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/underlying_type.pass.cpp
@@ -14,6 +14,8 @@
 #include <type_traits>
 #include <climits>
 
+#include "test_macros.h"
+
 enum E { V = INT_MIN };
 enum F { W = UINT_MAX };
 
@@ -29,7 +31,7 @@ int main()
     static_assert((std::is_same<std::underlying_type_t<F>, unsigned>::value), "");
 #endif
 
-#if __has_feature(cxx_strong_enums)
+#if TEST_STD_VER >= 11
     enum G : char { };
 
     static_assert((std::is_same<std::underlying_type<G>::type, char>::value),
@@ -37,5 +39,5 @@ int main()
 #if _LIBCPP_STD_VER > 11
     static_assert((std::is_same<std::underlying_type_t<G>, char>::value), "");
 #endif
-#endif // __has_feature(cxx_strong_enums)
+#endif // TEST_STD_VER >= 11
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.ptr/add_pointer.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.ptr/add_pointer.pass.cpp
index 76d0f12d03fb..51b3e5d73688 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.ptr/add_pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.ptr/add_pointer.pass.cpp
@@ -10,18 +10,42 @@
 // type_traits
 
 // add_pointer
+// If T names a referenceable type or a (possibly cv-qualified) void type then
+//    the member typedef type shall name the same type as remove_reference_t<T>*;
+//    otherwise, type shall name T.
 
 #include <type_traits>
+#include "test_macros.h"
 
 template <class T, class U>
 void test_add_pointer()
 {
     static_assert((std::is_same<typename std::add_pointer<T>::type, U>::value), "");
-#if _LIBCPP_STD_VER > 11
+#if TEST_STD_VER > 11
     static_assert((std::is_same<std::add_pointer_t<T>,     U>::value), "");
 #endif
 }
 
+template <class F>
+void test_function0()
+{
+    static_assert((std::is_same<typename std::add_pointer<F>::type, F*>::value), "");
+#if TEST_STD_VER > 11
+    static_assert((std::is_same<std::add_pointer_t<F>, F*>::value), "");
+#endif
+}
+
+template <class F>
+void test_function1()
+{
+    static_assert((std::is_same<typename std::add_pointer<F>::type, F>::value), "");
+#if TEST_STD_VER > 11
+    static_assert((std::is_same<std::add_pointer_t<F>, F>::value), "");
+#endif
+}
+
+struct Foo {};
+
 int main()
 {
     test_add_pointer<void, void*>();
@@ -31,4 +55,26 @@ int main()
     test_add_pointer<const int&, const int*>();
     test_add_pointer<int*, int**>();
     test_add_pointer<const int*, const int**>();
+    test_add_pointer<Foo, Foo*>();
+
+//  LWG 2101 specifically talks about add_pointer and functions.
+//  The term of art is "a referenceable type", which a cv- or ref-qualified function is not.
+    test_function0<void()>();
+#if TEST_STD_VER >= 11
+    test_function1<void() const>();
+    test_function1<void() &>();
+    test_function1<void() &&>();
+    test_function1<void() const &>();
+    test_function1<void() const &&>();
+#endif
+
+//  But a cv- or ref-qualified member function *is* "a referenceable type"
+    test_function0<void (Foo::*)()>();
+#if TEST_STD_VER >= 11
+    test_function0<void (Foo::*)() const>();
+    test_function0<void (Foo::*)() &>();
+    test_function0<void (Foo::*)() &&>();
+    test_function0<void (Foo::*)() const &>();
+    test_function0<void (Foo::*)() const &&>();
+#endif
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.ptr/remove_pointer.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.ptr/remove_pointer.pass.cpp
index 9cecd39049fc..cccbb6011edf 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.ptr/remove_pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.ptr/remove_pointer.pass.cpp
@@ -12,12 +12,13 @@
 // remove_pointer
 
 #include <type_traits>
+#include "test_macros.h"
 
 template <class T, class U>
 void test_remove_pointer()
 {
     static_assert((std::is_same<typename std::remove_pointer<T>::type, U>::value), "");
-#if _LIBCPP_STD_VER > 11
+#if TEST_STD_VER > 11
     static_assert((std::is_same<std::remove_pointer_t<T>,     U>::value), "");
 #endif
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.ref/add_lvalue_ref.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.ref/add_lvalue_ref.pass.cpp
index fb53312cbe67..c82c28299535 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.ref/add_lvalue_ref.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.ref/add_lvalue_ref.pass.cpp
@@ -10,14 +10,17 @@
 // type_traits
 
 // add_lvalue_reference
+// If T names a referenceable type then the member typedef type
+//    shall name T&; otherwise, type shall name T.
 
 #include <type_traits>
+#include "test_macros.h"
 
 template <class T, class U>
 void test_add_lvalue_reference()
 {
     static_assert((std::is_same<typename std::add_lvalue_reference<T>::type, U>::value), "");
-#if _LIBCPP_STD_VER > 11
+#if TEST_STD_VER > 11
     static_assert((std::is_same<std::add_lvalue_reference_t<T>, U>::value), "");
 #endif
 }
@@ -26,7 +29,7 @@ template <class F>
 void test_function0()
 {
     static_assert((std::is_same<typename std::add_lvalue_reference<F>::type, F&>::value), "");
-#if _LIBCPP_STD_VER > 11
+#if TEST_STD_VER > 11
     static_assert((std::is_same<std::add_lvalue_reference_t<F>, F&>::value), "");
 #endif
 }
@@ -35,7 +38,7 @@ template <class F>
 void test_function1()
 {
     static_assert((std::is_same<typename std::add_lvalue_reference<F>::type, F>::value), "");
-#if _LIBCPP_STD_VER > 11
+#if TEST_STD_VER > 11
     static_assert((std::is_same<std::add_lvalue_reference_t<F>, F>::value), "");
 #endif
 }
@@ -51,20 +54,26 @@ int main()
     test_add_lvalue_reference<const int&, const int&>();
     test_add_lvalue_reference<int*, int*&>();
     test_add_lvalue_reference<const int*, const int*&>();
+    test_add_lvalue_reference<Foo, Foo&>();
 
 //  LWG 2101 specifically talks about add_lvalue_reference and functions.
 //  The term of art is "a referenceable type", which a cv- or ref-qualified function is not.
     test_function0<void()>();
-//     test_function1<void() const>();
-//     test_function1<void() &>();
-//     test_function1<void() &&>();
-//     test_function1<void() const &>();
-//     test_function1<void() const &&>();
+#if TEST_STD_VER >= 11
+    test_function1<void() const>();
+    test_function1<void() &>();
+    test_function1<void() &&>();
+    test_function1<void() const &>();
+    test_function1<void() const &&>();
+#endif
 
+//  But a cv- or ref-qualified member function *is* "a referenceable type"
     test_function0<void (Foo::*)()>();
+#if TEST_STD_VER >= 11
     test_function0<void (Foo::*)() const>();
     test_function0<void (Foo::*)() &>();
     test_function0<void (Foo::*)() &&>();
     test_function0<void (Foo::*)() const &>();
     test_function0<void (Foo::*)() const &&>();
+#endif
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.ref/add_rvalue_ref.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.ref/add_rvalue_ref.pass.cpp
index e8f08fdc398a..fc147c37b1ac 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.ref/add_rvalue_ref.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.ref/add_rvalue_ref.pass.cpp
@@ -10,8 +10,11 @@
 // type_traits
 
 // add_rvalue_reference
+// If T names a referenceable type then the member typedef type
+//   shall name T&&; otherwise, type shall name T.
 
 #include <type_traits>
+#include "test_macros.h"
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
@@ -19,13 +22,32 @@ template <class T, class U>
 void test_add_rvalue_reference()
 {
     static_assert((std::is_same<typename std::add_rvalue_reference<T>::type, U>::value), "");
-#if _LIBCPP_STD_VER > 11
+#if TEST_STD_VER > 11
     static_assert((std::is_same<std::add_rvalue_reference_t<T>, U>::value), "");
 #endif
 }
 
+template <class F>
+void test_function0()
+{
+    static_assert((std::is_same<typename std::add_rvalue_reference<F>::type, F&&>::value), "");
+#if TEST_STD_VER > 11
+    static_assert((std::is_same<std::add_rvalue_reference_t<F>, F&&>::value), "");
+#endif
+}
+
+template <class F>
+void test_function1()
+{
+    static_assert((std::is_same<typename std::add_rvalue_reference<F>::type, F>::value), "");
+#if TEST_STD_VER > 11
+    static_assert((std::is_same<std::add_rvalue_reference_t<F>, F>::value), "");
+#endif
+}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
+struct Foo {};
+
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -36,5 +58,27 @@ int main()
     test_add_rvalue_reference<const int&, const int&>();
     test_add_rvalue_reference<int*, int*&&>();
     test_add_rvalue_reference<const int*, const int*&&>();
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    test_add_rvalue_reference<Foo, Foo&&>();
+
+//  LWG 2101 specifically talks about add_rvalue_reference and functions.
+//  The term of art is "a referenceable type", which a cv- or ref-qualified function is not.
+    test_function0<void()>();
+#if TEST_STD_VER >= 11
+    test_function1<void() const>();
+    test_function1<void() &>();
+    test_function1<void() &&>();
+    test_function1<void() const &>();
+    test_function1<void() const &&>();
+#endif
+
+//  But a cv- or ref-qualified member function *is* "a referenceable type"
+    test_function0<void (Foo::*)()>();
+#if TEST_STD_VER >= 11
+    test_function0<void (Foo::*)() const>();
+    test_function0<void (Foo::*)() &>();
+    test_function0<void (Foo::*)() &&>();
+    test_function0<void (Foo::*)() const &>();
+    test_function0<void (Foo::*)() const &&>();
+#endif
+#endif
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.ref/remove_ref.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.ref/remove_ref.pass.cpp
index f9ebc37a5dd2..e335bd19ef2d 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.ref/remove_ref.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.ref/remove_ref.pass.cpp
@@ -12,12 +12,13 @@
 // remove_reference
 
 #include <type_traits>
+#include "test_macros.h"
 
 template <class T, class U>
 void test_remove_reference()
 {
     static_assert((std::is_same<typename std::remove_reference<T>::type, U>::value), "");
-#if _LIBCPP_STD_VER > 11
+#if TEST_STD_VER > 11
     static_assert((std::is_same<std::remove_reference_t<T>, U>::value), "");
 #endif
 }
diff --git a/test/std/utilities/meta/meta.unary.prop.query/void_t.pass.cpp b/test/std/utilities/meta/meta.unary.prop.query/void_t.pass.cpp
index ccec65fec399..05ef99d0ebf4 100644
--- a/test/std/utilities/meta/meta.unary.prop.query/void_t.pass.cpp
+++ b/test/std/utilities/meta/meta.unary.prop.query/void_t.pass.cpp
@@ -57,7 +57,7 @@ int main()
     test1<Class>();
     test1<Class[]>();
     test1<Class[5]>();
-    
+
     test2<void, int>();
     test2<double, int>();
     test2<int&, int>();
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/array.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/array.pass.cpp
index f4dd356383af..ef1fc4040dc7 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/array.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/array.pass.cpp
@@ -12,12 +12,13 @@
 // array
 
 #include <type_traits>
+#include "test_macros.h"
 
 template <class T>
 void test_array_imp()
 {
     static_assert(!std::is_void<T>::value, "");
-#if _LIBCPP_STD_VER > 11
+#if TEST_STD_VER > 11
     static_assert(!std::is_null_pointer<T>::value, "");
 #endif
     static_assert(!std::is_integral<T>::value, "");
@@ -46,10 +47,15 @@ void test_array()
 typedef char array[3];
 typedef const char const_array[3];
 typedef char incomplete_array[];
+struct Incomplete;
 
 int main()
 {
     test_array<array>();
     test_array<const_array>();
     test_array<incomplete_array>();
+    test_array<Incomplete[]>();
+
+//  LWG#2582
+    static_assert(!std::is_array<Incomplete>::value, "");
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/class.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/class.pass.cpp
index ac5d6e592311..8c8510882bf6 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/class.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/class.pass.cpp
@@ -12,12 +12,13 @@
 // class
 
 #include <type_traits>
+#include "test_macros.h"
 
 template <class T>
 void test_class_imp()
 {
     static_assert(!std::is_void<T>::value, "");
-#if _LIBCPP_STD_VER > 11
+#if TEST_STD_VER > 11
     static_assert(!std::is_null_pointer<T>::value, "");
 #endif
     static_assert(!std::is_integral<T>::value, "");
@@ -47,7 +48,13 @@ class Class
 {
 };
 
+struct incomplete_type;
+
 int main()
 {
     test_class<Class>();
+    test_class<incomplete_type>();
+
+//  LWG#2582
+    static_assert( std::is_class<incomplete_type>::value, "");
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/enum.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/enum.pass.cpp
index 7c9c78fcf2b9..40dea443cd41 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/enum.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/enum.pass.cpp
@@ -12,12 +12,13 @@
 // enum
 
 #include <type_traits>
+#include "test_macros.h"
 
 template <class T>
 void test_enum_imp()
 {
     static_assert(!std::is_void<T>::value, "");
-#if _LIBCPP_STD_VER > 11
+#if TEST_STD_VER > 11
     static_assert(!std::is_null_pointer<T>::value, "");
 #endif
     static_assert(!std::is_integral<T>::value, "");
@@ -44,8 +45,12 @@ void test_enum()
 }
 
 enum Enum {zero, one};
+struct incomplete_type;
 
 int main()
 {
     test_enum<Enum>();
+
+//  LWG#2582
+    static_assert(!std::is_enum<incomplete_type>::value, "");
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/floating_point.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/floating_point.pass.cpp
index 286644960315..217bc7e25659 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/floating_point.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/floating_point.pass.cpp
@@ -12,12 +12,13 @@
 // floating_point
 
 #include <type_traits>
+#include "test_macros.h"
 
 template <class T>
 void test_floating_point_imp()
 {
     static_assert(!std::is_void<T>::value, "");
-#if _LIBCPP_STD_VER > 11
+#if TEST_STD_VER > 11
     static_assert(!std::is_null_pointer<T>::value, "");
 #endif
     static_assert(!std::is_integral<T>::value, "");
@@ -43,9 +44,14 @@ void test_floating_point()
     test_floating_point_imp<const volatile T>();
 }
 
+struct incomplete_type;
+
 int main()
 {
     test_floating_point<float>();
     test_floating_point<double>();
     test_floating_point<long double>();
+
+//  LWG#2582
+    static_assert(!std::is_floating_point<incomplete_type>::value, "");
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/function.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/function.pass.cpp
index b1df4f2d3f4c..3f21b9a7dbcf 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/function.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/function.pass.cpp
@@ -12,13 +12,14 @@
 // function
 
 #include <type_traits>
+#include "test_macros.h"
 
 using namespace std;
 
 class Class {};
 
 enum Enum1 {};
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
 enum class Enum2 : int {};
 #else
 enum Enum2 {};
@@ -28,7 +29,7 @@ template <class T>
 void test()
 {
     static_assert(!std::is_void<T>::value, "");
-#if _LIBCPP_STD_VER > 11
+#if TEST_STD_VER > 11
     static_assert(!std::is_null_pointer<T>::value, "");
 #endif
     static_assert(!std::is_integral<T>::value, "");
@@ -64,6 +65,7 @@ void test()
     test<__VA_ARGS__ volatile &&>();      \
     test<__VA_ARGS__ const volatile &&>()
 
+struct incomplete_type;
 
 int main()
 {
@@ -75,7 +77,7 @@ int main()
     TEST_REGULAR( void (int, ...) );
     TEST_REGULAR( int (double, ...) );
     TEST_REGULAR( int (double, char, ...) );
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
     TEST_REF_QUALIFIED( void () );
     TEST_REF_QUALIFIED( void (int) );
     TEST_REF_QUALIFIED( int (double) );
@@ -85,4 +87,7 @@ int main()
     TEST_REF_QUALIFIED( int (double, ...) );
     TEST_REF_QUALIFIED( int (double, char, ...) );
 #endif
+
+//  LWG#2582
+    static_assert(!std::is_function<incomplete_type>::value, "");
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/integral.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/integral.pass.cpp
index f68ed3ef7e57..a50beeb3e310 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/integral.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/integral.pass.cpp
@@ -12,12 +12,13 @@
 // integral
 
 #include <type_traits>
+#include "test_macros.h"
 
 template <class T>
 void test_integral_imp()
 {
     static_assert(!std::is_void<T>::value, "");
-#if _LIBCPP_STD_VER > 11
+#if TEST_STD_VER > 11
     static_assert(!std::is_null_pointer<T>::value, "");
 #endif
     static_assert( std::is_integral<T>::value, "");
@@ -43,6 +44,8 @@ void test_integral()
     test_integral_imp<const volatile T>();
 }
 
+struct incomplete_type;
+
 int main()
 {
     test_integral<bool>();
@@ -62,4 +65,7 @@ int main()
     test_integral<__int128_t>();
     test_integral<__uint128_t>();
 #endif
+
+//  LWG#2582
+    static_assert(!std::is_integral<incomplete_type>::value, "");
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_array.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_array.pass.cpp
index 72955defa399..dfd09ac52bfa 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_array.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_array.pass.cpp
@@ -12,7 +12,7 @@
 // is_array
 
 #include <type_traits>
-#include <cstddef>        // for std::nullptr_t 
+#include <cstddef>        // for std::nullptr_t
 #include "test_macros.h"
 
 template <class T>
@@ -67,6 +67,7 @@ class Abstract
 };
 
 enum Enum {zero, one};
+struct incomplete_type;
 
 typedef void (*FunctionPtr)();
 
@@ -89,5 +90,5 @@ int main()
     test_is_not_array<Empty>();
     test_is_not_array<bit_zero>();
     test_is_not_array<NotEmpty>();
-    test_is_not_array<Abstract>();
+    test_is_not_array<incomplete_type>();  //  LWG#2582
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_class.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_class.pass.cpp
index 97671e7b62e0..3c1a2181d261 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_class.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_class.pass.cpp
@@ -67,6 +67,7 @@ class Abstract
 };
 
 enum Enum {zero, one};
+struct incomplete_type;
 
 typedef void (*FunctionPtr)();
 
@@ -76,6 +77,7 @@ int main()
     test_is_class<bit_zero>();
     test_is_class<NotEmpty>();
     test_is_class<Abstract>();
+    test_is_class<incomplete_type>();
 
 #if TEST_STD_VER >= 11
 // In C++03 we have an emulation of std::nullptr_t
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_enum.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_enum.pass.cpp
index 481260ea6e52..2603bdff26d2 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_enum.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_enum.pass.cpp
@@ -67,6 +67,7 @@ class Abstract
 };
 
 enum Enum {zero, one};
+struct incomplete_type;
 
 typedef void (*FunctionPtr)();
 
@@ -90,4 +91,5 @@ int main()
     test_is_not_enum<NotEmpty>();
     test_is_not_enum<Abstract>();
     test_is_not_enum<FunctionPtr>();
+    test_is_not_enum<incomplete_type>();
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_floating_point.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_floating_point.pass.cpp
index de9c146bcb4e..7e19c0629672 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_floating_point.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_floating_point.pass.cpp
@@ -67,6 +67,7 @@ class Abstract
 };
 
 enum Enum {zero, one};
+struct incomplete_type;
 
 typedef void (*FunctionPtr)();
 
@@ -98,4 +99,5 @@ int main()
     test_is_not_floating_point<Abstract>();
     test_is_not_floating_point<Enum>();
     test_is_not_floating_point<FunctionPtr>();
+    test_is_not_floating_point<incomplete_type>();
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_function.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_function.pass.cpp
index 9a1d821b0746..32e4f06beb04 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_function.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_function.pass.cpp
@@ -67,6 +67,7 @@ class Abstract
 };
 
 enum Enum {zero, one};
+struct incomplete_type;
 
 typedef void (*FunctionPtr)();
 
@@ -77,7 +78,7 @@ int main()
 	test_is_function<int(int, double)>();
 	test_is_function<int(Abstract *)>();
 	test_is_function<void(...)>();
-	
+
     test_is_not_function<std::nullptr_t>();
     test_is_not_function<void>();
     test_is_not_function<int>();
@@ -95,4 +96,5 @@ int main()
     test_is_not_function<NotEmpty>();
     test_is_not_function<Abstract>();
     test_is_not_function<Abstract*>();
+    test_is_not_function<incomplete_type>();
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_integral.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_integral.pass.cpp
index 86b63c53da54..09997626ea06 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_integral.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_integral.pass.cpp
@@ -67,6 +67,7 @@ class Abstract
 };
 
 enum Enum {zero, one};
+struct incomplete_type;
 
 typedef void (*FunctionPtr)();
 
@@ -101,4 +102,5 @@ int main()
     test_is_not_integral<bit_zero>();
     test_is_not_integral<NotEmpty>();
     test_is_not_integral<Abstract>();
+    test_is_not_integral<incomplete_type>();
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_lvalue_reference.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_lvalue_reference.pass.cpp
index 0e59f7153f50..41b8d44b9315 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_lvalue_reference.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_lvalue_reference.pass.cpp
@@ -69,6 +69,7 @@ class Abstract
 };
 
 enum Enum {zero, one};
+struct incomplete_type;
 
 typedef void (*FunctionPtr)();
 
@@ -92,4 +93,5 @@ int main()
     test_is_not_lvalue_reference<bit_zero>();
     test_is_not_lvalue_reference<NotEmpty>();
     test_is_not_lvalue_reference<Abstract>();
+    test_is_not_lvalue_reference<incomplete_type>();
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_member_object_pointer.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_member_object_pointer.pass.cpp
index 8da411d2eeed..9498edc652ab 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_member_object_pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_member_object_pointer.pass.cpp
@@ -67,6 +67,7 @@ class Abstract
 };
 
 enum Enum {zero, one};
+struct incomplete_type;
 
 typedef void (*FunctionPtr)();
 
@@ -94,4 +95,5 @@ int main()
     test_is_not_member_object_pointer<bit_zero>();
     test_is_not_member_object_pointer<NotEmpty>();
     test_is_not_member_object_pointer<Abstract>();
+    test_is_not_member_object_pointer<incomplete_type>();
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_member_pointer.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_member_pointer.pass.cpp
index 19a74b01d0fd..d4043f48f98e 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_member_pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_member_pointer.pass.cpp
@@ -67,6 +67,7 @@ class Abstract
 };
 
 enum Enum {zero, one};
+struct incomplete_type;
 
 typedef void (*FunctionPtr)();
 
@@ -95,4 +96,5 @@ int main()
     test_is_not_member_pointer<bit_zero>();
     test_is_not_member_pointer<NotEmpty>();
     test_is_not_member_pointer<Abstract>();
+    test_is_not_member_pointer<incomplete_type>();
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_null_pointer.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_null_pointer.pass.cpp
index 80f563e8969e..f575763300a7 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_null_pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_null_pointer.pass.cpp
@@ -69,6 +69,7 @@ class Abstract
 };
 
 enum Enum {zero, one};
+struct incomplete_type;
 
 typedef void (*FunctionPtr)();
 
@@ -92,4 +93,5 @@ int main()
     test_is_not_null_pointer<bit_zero>();
     test_is_not_null_pointer<NotEmpty>();
     test_is_not_null_pointer<Abstract>();
+    test_is_not_null_pointer<incomplete_type>();
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_pointer.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_pointer.pass.cpp
index a901aed1143e..257719eb940e 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_pointer.pass.cpp
@@ -67,6 +67,7 @@ class Abstract
 };
 
 enum Enum {zero, one};
+struct incomplete_type;
 
 typedef void (*FunctionPtr)();
 
@@ -91,4 +92,5 @@ int main()
     test_is_not_pointer<bit_zero>();
     test_is_not_pointer<NotEmpty>();
     test_is_not_pointer<Abstract>();
+    test_is_not_pointer<incomplete_type>();
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_rvalue_reference.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_rvalue_reference.pass.cpp
index b7b52687018a..89639377ce81 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_rvalue_reference.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_rvalue_reference.pass.cpp
@@ -69,6 +69,7 @@ class Abstract
 };
 
 enum Enum {zero, one};
+struct incomplete_type;
 
 typedef void (*FunctionPtr)();
 
@@ -92,4 +93,5 @@ int main()
     test_is_not_rvalue_reference<bit_zero>();
     test_is_not_rvalue_reference<NotEmpty>();
     test_is_not_rvalue_reference<Abstract>();
+    test_is_not_rvalue_reference<incomplete_type>();
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_union.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_union.pass.cpp
index 307fedb32b26..415d9a7813dd 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_union.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_union.pass.cpp
@@ -67,6 +67,7 @@ class Abstract
 };
 
 enum Enum {zero, one};
+struct incomplete_type;
 
 typedef void (*FunctionPtr)();
 
@@ -90,4 +91,5 @@ int main()
     test_is_not_union<bit_zero>();
     test_is_not_union<NotEmpty>();
     test_is_not_union<Abstract>();
+    test_is_not_union<incomplete_type>();
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_void.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_void.pass.cpp
index 1647666adf2e..952a5b748f53 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_void.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_void.pass.cpp
@@ -67,6 +67,7 @@ class Abstract
 };
 
 enum Enum {zero, one};
+struct incomplete_type;
 
 typedef void (*FunctionPtr)();
 
@@ -89,4 +90,5 @@ int main()
     test_is_not_void<Abstract>();
     test_is_not_void<Enum>();
     test_is_not_void<FunctionPtr>();
+    test_is_not_void<incomplete_type>();
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/lvalue_ref.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/lvalue_ref.pass.cpp
index 3b6ccade7e74..13cad58c0ef3 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/lvalue_ref.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/lvalue_ref.pass.cpp
@@ -34,8 +34,13 @@ void test_lvalue_ref()
     static_assert(!std::is_function<T>::value, "");
 }
 
+struct incomplete_type;
+
 int main()
 {
     test_lvalue_ref<int&>();
     test_lvalue_ref<const int&>();
+
+//  LWG#2582
+    static_assert(!std::is_lvalue_reference<incomplete_type>::value, "");
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer.pass.cpp
index 6f546efdf51e..a895a8d447b6 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer.pass.cpp
@@ -48,6 +48,8 @@ class Class
 {
 };
 
+struct incomplete_type;
+
 int main()
 {
     test_member_function_pointer<void (Class::*)()>();
@@ -133,4 +135,7 @@ int main()
     test_member_function_pointer<void (Class::*)(int,...) const volatile &&>();
     test_member_function_pointer<void (Class::*)(int, char,...) const volatile &&>();
 #endif
+
+//  LWG#2582
+    static_assert(!std::is_member_function_pointer<incomplete_type>::value, "");
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer_no_variadics.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer_no_variadics.pass.cpp
index e13e58632a32..b0edea37e8e8 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer_no_variadics.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer_no_variadics.pass.cpp
@@ -48,6 +48,8 @@ class Class
 {
 };
 
+struct incomplete_type;
+
 int main()
 {
     test_member_function_pointer<void (Class::*)()>();
@@ -73,4 +75,7 @@ int main()
     test_member_function_pointer<void (Class::*)(...) volatile>();
     test_member_function_pointer<void (Class::*)(int, ...) volatile>();
     test_member_function_pointer<void (Class::*)(int, char, ...) volatile>();
+
+//  LWG#2582
+    static_assert(!std::is_member_function_pointer<incomplete_type>::value, "");
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/member_object_pointer.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/member_object_pointer.pass.cpp
index 4e6699cc3e7c..76deef4291e7 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/member_object_pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/member_object_pointer.pass.cpp
@@ -12,12 +12,13 @@
 // member_object_pointer
 
 #include <type_traits>
+#include "test_macros.h"
 
 template <class T>
 void test_member_object_pointer_imp()
 {
     static_assert(!std::is_void<T>::value, "");
-#if _LIBCPP_STD_VER > 11
+#if TEST_STD_VER > 11
     static_assert(!std::is_null_pointer<T>::value, "");
 #endif
     static_assert(!std::is_integral<T>::value, "");
@@ -47,7 +48,12 @@ class Class
 {
 };
 
+struct incomplete_type;
+
 int main()
 {
     test_member_object_pointer<int Class::*>();
+
+//  LWG#2582
+    static_assert(!std::is_member_object_pointer<incomplete_type>::value, "");
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/nullptr.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/nullptr.pass.cpp
index 1c7a32fc9dc9..076204c9c094 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/nullptr.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/nullptr.pass.cpp
@@ -14,8 +14,9 @@
 
 #include <type_traits>
 #include <cstddef>        // for std::nullptr_t
+#include "test_macros.h"
 
-#if _LIBCPP_STD_VER > 11
+#if TEST_STD_VER > 11
 template <class T>
 void test_nullptr_imp()
 {
@@ -44,9 +45,14 @@ void test_nullptr()
     test_nullptr_imp<const volatile T>();
 }
 
+struct incomplete_type;
+
 int main()
 {
     test_nullptr<std::nullptr_t>();
+
+//  LWG#2582
+    static_assert(!std::is_null_pointer<incomplete_type>::value, "");
 }
 #else
 int main() {}
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/pointer.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/pointer.pass.cpp
index 7073c106b44b..f9c83c67d219 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/pointer.pass.cpp
@@ -12,12 +12,14 @@
 // pointer
 
 #include <type_traits>
+#include "test_macros.h"
+
 
 template <class T>
 void test_pointer_imp()
 {
     static_assert(!std::is_void<T>::value, "");
-#if _LIBCPP_STD_VER > 11
+#if TEST_STD_VER > 11
     static_assert(!std::is_null_pointer<T>::value, "");
 #endif
     static_assert(!std::is_integral<T>::value, "");
@@ -43,10 +45,15 @@ void test_pointer()
     test_pointer_imp<const volatile T>();
 }
 
+struct incomplete_type;
+
 int main()
 {
     test_pointer<void*>();
     test_pointer<int*>();
     test_pointer<const int*>();
     test_pointer<void (*)(int)>();
+
+//  LWG#2582
+    static_assert(!std::is_pointer<incomplete_type>::value, "");
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/rvalue_ref.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/rvalue_ref.pass.cpp
index 796442403634..99fd2887981f 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/rvalue_ref.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/rvalue_ref.pass.cpp
@@ -12,12 +12,13 @@
 // rvalue_ref
 
 #include <type_traits>
+#include "test_macros.h"
 
 template <class T>
 void test_rvalue_ref()
 {
     static_assert(!std::is_void<T>::value, "");
-#if _LIBCPP_STD_VER > 11
+#if TEST_STD_VER > 11
     static_assert(!std::is_null_pointer<T>::value, "");
 #endif
     static_assert(!std::is_integral<T>::value, "");
@@ -34,10 +35,15 @@ void test_rvalue_ref()
     static_assert(!std::is_function<T>::value, "");
 }
 
+struct incomplete_type;
+
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     test_rvalue_ref<int&&>();
     test_rvalue_ref<const int&&>();
+
+//  LWG#2582
+    static_assert(!std::is_rvalue_reference<incomplete_type>::value, "");
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/union.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/union.pass.cpp
index 6cabb717c0c6..36ad00400d35 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/union.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/union.pass.cpp
@@ -12,12 +12,13 @@
 // union
 
 #include <type_traits>
+#include "test_macros.h"
 
 template <class T>
 void test_union_imp()
 {
     static_assert(!std::is_void<T>::value, "");
-#if _LIBCPP_STD_VER > 11
+#if TEST_STD_VER > 11
     static_assert(!std::is_null_pointer<T>::value, "");
 #endif
     static_assert(!std::is_integral<T>::value, "");
@@ -49,7 +50,12 @@ union Union
     double __;
 };
 
+struct incomplete_type;
+
 int main()
 {
     test_union<Union>();
+
+//  LWG#2582
+    static_assert(!std::is_union<incomplete_type>::value, "");
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/void.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/void.pass.cpp
index f20bcf87ea15..c7597eb4eaf7 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/void.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/void.pass.cpp
@@ -12,12 +12,13 @@
 // void
 
 #include <type_traits>
+#include "test_macros.h"
 
 template <class T>
 void test_void_imp()
 {
     static_assert( std::is_void<T>::value, "");
-#if _LIBCPP_STD_VER > 11
+#if TEST_STD_VER > 11
     static_assert(!std::is_null_pointer<T>::value, "");
 #endif
     static_assert(!std::is_integral<T>::value, "");
@@ -43,7 +44,12 @@ void test_void()
     test_void_imp<const volatile T>();
 }
 
+struct incomplete_type;
+
 int main()
 {
     test_void<void>();
+
+//  LWG#2582
+    static_assert(!std::is_void<incomplete_type>::value, "");
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/array.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/array.pass.cpp
index 3476d5ceea2b..f601bd12cadb 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/array.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/array.pass.cpp
@@ -38,9 +38,12 @@ typedef char array[3];
 typedef const char const_array[3];
 typedef char incomplete_array[];
 
+class incomplete_type;
+
 int main()
 {
     test_array<array>();
     test_array<const_array>();
     test_array<incomplete_array>();
+    test_array<incomplete_type[]>();
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/class.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/class.pass.cpp
index 49e41380ca27..5fa5da12aef8 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/class.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/class.pass.cpp
@@ -38,7 +38,10 @@ class Class
 {
 };
 
+class incomplete_type;
+
 int main()
 {
     test_class<Class>();
+    test_class<incomplete_type>();
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_arithmetic.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_arithmetic.pass.cpp
index a3f18d52a706..02c539712c65 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_arithmetic.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_arithmetic.pass.cpp
@@ -45,6 +45,8 @@ void test_is_not_arithmetic()
 #endif
 }
 
+class incomplete_type;
+
 class Empty
 {
 };
@@ -98,6 +100,7 @@ int main()
     test_is_not_arithmetic<Enum>();
     test_is_not_arithmetic<FunctionPtr>();
     test_is_not_arithmetic<Empty>();
+    test_is_not_arithmetic<incomplete_type>();
     test_is_not_arithmetic<bit_zero>();
     test_is_not_arithmetic<NotEmpty>();
     test_is_not_arithmetic<Abstract>();
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_compound.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_compound.pass.cpp
index 6a1798ab5adc..d8d5162c1a02 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_compound.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_compound.pass.cpp
@@ -45,6 +45,8 @@ void test_is_not_compound()
 #endif
 }
 
+class incomplete_type;
+
 class Empty
 {
 };
@@ -81,6 +83,7 @@ int main()
     test_is_compound<int&&>();
     test_is_compound<Union>();
     test_is_compound<Empty>();
+    test_is_compound<incomplete_type>();
     test_is_compound<bit_zero>();
     test_is_compound<int*>();
     test_is_compound<const int*>();
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_fundamental.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_fundamental.pass.cpp
index e16337e05f1c..f776196dd7a9 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_fundamental.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_fundamental.pass.cpp
@@ -45,6 +45,8 @@ void test_is_not_fundamental()
 #endif
 }
 
+class incomplete_type;
+
 class Empty
 {
 };
@@ -94,7 +96,7 @@ int main()
 	test_is_fundamental<long double>();
 	test_is_fundamental<char16_t>();
 	test_is_fundamental<char32_t>();
-	
+
     test_is_not_fundamental<char[3]>();
     test_is_not_fundamental<char[]>();
     test_is_not_fundamental<void *>();
@@ -103,6 +105,7 @@ int main()
     test_is_not_fundamental<int&&>();
     test_is_not_fundamental<Union>();
     test_is_not_fundamental<Empty>();
+    test_is_not_fundamental<incomplete_type>();
     test_is_not_fundamental<bit_zero>();
     test_is_not_fundamental<int*>();
     test_is_not_fundamental<const int*>();
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_member_pointer.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_member_pointer.pass.cpp
index 890da659e218..c2804885ac50 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_member_pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_member_pointer.pass.cpp
@@ -45,6 +45,8 @@ void test_is_not_member_pointer()
 #endif
 }
 
+class incomplete_type;
+
 class Empty
 {
 };
@@ -73,9 +75,9 @@ typedef void (*FunctionPtr)();
 
 int main()
 {
-//  Arithmetic types (3.9.1), enumeration types, pointer types, pointer to member types (3.9.2), 
-//    std::nullptr_t, and cv-qualified versions of these types (3.9.3) 
-//    are collectively called scalar types. 
+//  Arithmetic types (3.9.1), enumeration types, pointer types, pointer to member types (3.9.2),
+//    std::nullptr_t, and cv-qualified versions of these types (3.9.3)
+//    are collectively called scalar types.
 
     test_is_member_pointer<int Empty::*>();
     test_is_member_pointer<void (Empty::*)(int)>();
@@ -93,6 +95,7 @@ int main()
     test_is_not_member_pointer<char[]>();
     test_is_not_member_pointer<Union>();
     test_is_not_member_pointer<Empty>();
+    test_is_not_member_pointer<incomplete_type>();
     test_is_not_member_pointer<bit_zero>();
     test_is_not_member_pointer<NotEmpty>();
     test_is_not_member_pointer<Abstract>();
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_object.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_object.pass.cpp
index ff7dda30d111..311215b81643 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_object.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_object.pass.cpp
@@ -45,6 +45,8 @@ void test_is_not_object()
 #endif
 }
 
+class incomplete_type;
+
 class Empty
 {
 };
@@ -73,7 +75,7 @@ typedef void (*FunctionPtr)();
 
 int main()
 {
-// An object type is a (possibly cv-qualified) type that is not a function type, 
+// An object type is a (possibly cv-qualified) type that is not a function type,
 // not a reference type, and not a void type.
 
     test_is_object<std::nullptr_t>();
@@ -86,8 +88,8 @@ int main()
     test_is_object<int*>();
     test_is_object<const int*>();
     test_is_object<Enum>();
-    test_is_object<Empty>();
-    test_is_object<bit_zero>();	
+    test_is_object<incomplete_type>();
+    test_is_object<bit_zero>();
     test_is_object<NotEmpty>();
     test_is_object<Abstract>();
     test_is_object<FunctionPtr>();
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_reference.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_reference.pass.cpp
index e56c8f761814..b546458bdcb8 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_reference.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_reference.pass.cpp
@@ -45,6 +45,8 @@ void test_is_not_reference()
 #endif
 }
 
+class incomplete_type;
+
 class Empty
 {
 };
@@ -87,6 +89,7 @@ int main()
     test_is_not_reference<void *>();
     test_is_not_reference<FunctionPtr>();
     test_is_not_reference<Union>();
+    test_is_not_reference<incomplete_type>();
     test_is_not_reference<Empty>();
     test_is_not_reference<bit_zero>();
     test_is_not_reference<int*>();
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_scalar.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_scalar.pass.cpp
index 2b412a68833b..39ac07ad4bc5 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_scalar.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_scalar.pass.cpp
@@ -45,6 +45,8 @@ void test_is_not_scalar()
 #endif
 }
 
+class incomplete_type;
+
 class Empty
 {
 };
@@ -73,9 +75,9 @@ typedef void (*FunctionPtr)();
 
 int main()
 {
-//  Arithmetic types (3.9.1), enumeration types, pointer types, pointer to member types (3.9.2), 
-//    std::nullptr_t, and cv-qualified versions of these types (3.9.3) 
-//    are collectively called scalar types. 
+//  Arithmetic types (3.9.1), enumeration types, pointer types, pointer to member types (3.9.2),
+//    std::nullptr_t, and cv-qualified versions of these types (3.9.3)
+//    are collectively called scalar types.
 
     test_is_scalar<std::nullptr_t>();
     test_is_scalar<short>();
@@ -104,6 +106,7 @@ int main()
     test_is_not_scalar<char[]>();
     test_is_not_scalar<Union>();
     test_is_not_scalar<Empty>();
+    test_is_not_scalar<incomplete_type>();
     test_is_not_scalar<bit_zero>();
     test_is_not_scalar<NotEmpty>();
     test_is_not_scalar<Abstract>();
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/has_virtual_destructor.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/has_virtual_destructor.pass.cpp
index 36020139ec58..7330f4b35125 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/has_virtual_destructor.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/has_virtual_destructor.pass.cpp
@@ -13,6 +13,8 @@
 
 #include <type_traits>
 
+#include "test_macros.h"
+
 template <class T>
 void test_has_virtual_destructor()
 {
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp
index c0f6bb9bdfaf..b734a1aa60d8 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp
@@ -77,7 +77,7 @@ int main()
     test_is_not_assignable<void, const void> ();
     test_is_not_assignable<const void, const void> ();
     test_is_not_assignable<int(), int> ();
-    
+
 //  pointer to incomplete template type
 	test_is_assignable<X<D>*&, X<D>*> ();
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_const.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_const.pass.cpp
index 7f63ae40aca7..616f25180a60 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_const.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_const.pass.cpp
@@ -29,6 +29,8 @@ void test_is_const()
 #endif
 }
 
+struct A; // incomplete
+
 int main()
 {
     test_is_const<void>();
@@ -39,6 +41,8 @@ int main()
     test_is_const<char[3]>();
     test_is_const<char[]>();
 
+    test_is_const<A>();
+
     static_assert(!std::is_const<int&>::value, "");
     static_assert(!std::is_const<const int&>::value, "");
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp
index 5401d95532b1..9f8fdc7fc635 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp
@@ -8,6 +8,8 @@
 //===----------------------------------------------------------------------===//
 
 // type_traits
+// XFAIL: apple-clang-6.0
+//	The Apple-6 compiler gets is_constructible<void ()> wrong.
 
 // template <class T, class... Args>
 //   struct is_constructible;
@@ -19,7 +21,7 @@ struct A
 {
     explicit A(int);
     A(int, double);
-#if __has_feature(cxx_access_control_sfinae) 
+#if TEST_STD_VER >= 11
 private:
 #endif
     A(char);
@@ -89,7 +91,7 @@ int main()
     test_is_constructible<int&, int&> ();
 
     test_is_not_constructible<A> ();
-#if __has_feature(cxx_access_control_sfinae) 
+#if TEST_STD_VER >= 11
     test_is_not_constructible<A, char> ();
 #else
     test_is_constructible<A, char> ();
@@ -99,4 +101,13 @@ int main()
     test_is_not_constructible<int&> ();
     test_is_not_constructible<Abstract> ();
     test_is_not_constructible<AbstractDestructor> ();
+
+//  LWG 2560  -- postpone this test until bots updated
+//     test_is_not_constructible<void()> ();
+#if TEST_STD_VER > 11
+//     test_is_not_constructible<void() const> ();
+//     test_is_not_constructible<void() volatile> ();
+//     test_is_not_constructible<void() &> ();
+//     test_is_not_constructible<void() &&> ();
+#endif
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_assignable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_assignable.pass.cpp
index 421f865a623c..ac8b80bbd3a4 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_assignable.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_assignable.pass.cpp
@@ -79,7 +79,7 @@ int main()
     test_is_not_copy_assignable<int[]> ();
     test_is_not_copy_assignable<int[3]> ();
 #endif
-#if __has_feature(cxx_access_control_sfinae) 
+#if TEST_STD_VER >= 11
     test_is_not_copy_assignable<B> ();
 #endif
     test_is_not_copy_assignable<void> ();
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_constructible.pass.cpp
index fe2e01429b22..684d85d3d40c 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_constructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_constructible.pass.cpp
@@ -89,7 +89,7 @@ int main()
     test_is_not_copy_constructible<void>();
     test_is_not_copy_constructible<Abstract>();
     test_is_not_copy_constructible<C>();
-#if __has_feature(cxx_access_control_sfinae) 
+#if TEST_STD_VER >= 11
     test_is_not_copy_constructible<B>();
 #endif
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_default_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_default_constructible.pass.cpp
index 7b46eeaab66b..318147e5d4a3 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_default_constructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_default_constructible.pass.cpp
@@ -100,7 +100,7 @@ int main()
     test_is_not_default_constructible<char[]>();
     test_is_not_default_constructible<Abstract>();
     test_is_not_default_constructible<NoDefaultConstructor>();
-#if __has_feature(cxx_access_control_sfinae) 
+#if TEST_STD_VER >= 11
     test_is_not_default_constructible<B>();
 #endif
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp
index 60d607aba61c..5e8bfeaa41d2 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp
@@ -11,9 +11,15 @@
 
 // is_destructible
 
+// Prevent warning when testing the Abstract test type.
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wdelete-non-virtual-dtor"
+#endif
+
 #include <type_traits>
 #include "test_macros.h"
 
+
 template <class T>
 void test_is_destructible()
 {
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_final.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_final.pass.cpp
index baf85e3e8139..5a440598bb02 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_final.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_final.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // type_traits
 
 // is_final
@@ -14,8 +15,6 @@
 #include <type_traits>
 #include "test_macros.h"
 
-#if _LIBCPP_STD_VER > 11
-
 struct P final { };
 union U1 { };
 union U2 final { };
@@ -54,13 +53,10 @@ int main ()
 {
     test_is_not_final<int>();
     test_is_not_final<int*>();
-    test_is_final    <P>(); 
-    test_is_not_final<P*>();    
+    test_is_final    <P>();
+    test_is_not_final<P*>();
     test_is_not_final<U1>();
     test_is_not_final<U1*>();
-    test_is_final    <U2>();    
-    test_is_not_final<U2*>();   
+    test_is_final    <U2>();
+    test_is_not_final<U2*>();
 }
-#else
-int main () {}
-#endif
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_constructible.pass.cpp
index c778a5d24b2e..8200b468fe3a 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_constructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_constructible.pass.cpp
@@ -107,7 +107,7 @@ int main()
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     test_is_nothrow_constructible<Tuple &&, Empty> (); // See bug #19616.
 #endif
-    
+
     test_is_not_nothrow_constructible<A, int> ();
     test_is_not_nothrow_constructible<A, int, double> ();
     test_is_not_nothrow_constructible<A> ();
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp
index 42c9807efa83..58e0e0f98b58 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp
@@ -11,6 +11,11 @@
 
 // is_nothrow_destructible
 
+// Prevent warning when testing the Abstract test type.
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wdelete-non-virtual-dtor"
+#endif
+
 #include <type_traits>
 #include "test_macros.h"
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable.pass.cpp
new file mode 100644
index 000000000000..7510b4e7293c
--- /dev/null
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable.pass.cpp
@@ -0,0 +1,83 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11, c++14
+
+// type_traits
+
+// is_swappable
+
+#include <type_traits>
+#include <vector>
+#include "test_macros.h"
+
+namespace MyNS {
+
+// Make the test types non-copyable so that generic std::swap is not valid.
+struct A {
+  A(A const&) = delete;
+  A& operator=(A const&) = delete;
+};
+
+struct B {
+  B(B const&) = delete;
+  B& operator=(B const&) = delete;
+};
+
+void swap(A&, A&) noexcept {}
+void swap(B&, B&) {}
+
+struct M {
+  M(M const&) = delete;
+  M& operator=(M const&) = delete;
+};
+
+void swap(M&&, M&&) noexcept {}
+
+struct ThrowingMove {
+    ThrowingMove(ThrowingMove&&) {}
+    ThrowingMove& operator=(ThrowingMove&&) { return *this; }
+};
+
+} // namespace MyNS
+
+int main()
+{
+    using namespace MyNS;
+    {
+        // Test that is_swappable applies an lvalue reference to the type.
+        static_assert(std::is_nothrow_swappable<int>::value, "");
+        static_assert(std::is_nothrow_swappable<int&>::value, "");
+        static_assert(!std::is_nothrow_swappable<M>::value, "");
+        static_assert(!std::is_nothrow_swappable<M&&>::value, "");
+    }
+    {
+        // Test that it correctly deduces the noexcept of swap.
+        static_assert(std::is_nothrow_swappable<A>::value, "");
+        static_assert(!std::is_nothrow_swappable<B>::value
+                      && std::is_swappable<B>::value, "");
+        static_assert(!std::is_nothrow_swappable<ThrowingMove>::value
+                      && std::is_swappable<ThrowingMove>::value, "");
+    }
+    {
+        // Test that it doesn't drop the qualifiers
+        static_assert(!std::is_nothrow_swappable<const A>::value, "");
+    }
+    {
+        // test non-referenceable types
+        static_assert(!std::is_nothrow_swappable<void>::value, "");
+        static_assert(!std::is_nothrow_swappable<int() const>::value, "");
+        static_assert(!std::is_nothrow_swappable<int(int, ...) const &>::value, "");
+    }
+    {
+        // test for presence of is_nothrow_swappable_v
+        static_assert(std::is_nothrow_swappable_v<int>, "");
+        static_assert(!std::is_nothrow_swappable_v<void>, "");
+    }
+}
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable_with.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable_with.pass.cpp
new file mode 100644
index 000000000000..408231f6057f
--- /dev/null
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable_with.pass.cpp
@@ -0,0 +1,81 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11, c++14
+
+// type_traits
+
+// is_nothrow_swappable_with
+
+#include <type_traits>
+#include <vector>
+#include "test_macros.h"
+
+namespace MyNS {
+
+struct A {
+  A(A const&) = delete;
+  A& operator=(A const&) = delete;
+};
+
+struct B {
+  B(B const&) = delete;
+  B& operator=(B const&) = delete;
+};
+
+struct C {};
+struct D {};
+
+void swap(A&, A&) {}
+
+void swap(A&, B&) noexcept {}
+void swap(B&, A&) noexcept {}
+
+void swap(A&, C&) noexcept {}
+void swap(C&, A&) {}
+
+struct M {};
+
+void swap(M&&, M&&) noexcept {}
+
+} // namespace MyNS
+
+int main()
+{
+    using namespace MyNS;
+    {
+        // Test that is_swappable_with doesn't apply an lvalue reference
+        // to the type. Instead it is up to the user.
+        static_assert(!std::is_nothrow_swappable_with<int, int>::value, "");
+        static_assert(std::is_nothrow_swappable_with<int&, int&>::value, "");
+        static_assert(std::is_nothrow_swappable_with<M, M>::value, "");
+        static_assert(std::is_swappable_with<A&, A&>::value &&
+                      !std::is_nothrow_swappable_with<A&, A&>::value, "");
+    }
+    {
+        // test that hetrogenius swap is allowed only if both 'swap(A, B)' and
+        // 'swap(B, A)' are valid.
+        static_assert(std::is_nothrow_swappable_with<A&, B&>::value, "");
+        static_assert(!std::is_nothrow_swappable_with<A&, C&>::value &&
+                      std::is_swappable_with<A&, C&>::value, "");
+        static_assert(!std::is_nothrow_swappable_with<D&, C&>::value, "");
+    }
+    {
+        // test we guard against cv void inputs as required.
+        static_assert(!std::is_nothrow_swappable_with_v<void, int>, "");
+        static_assert(!std::is_nothrow_swappable_with_v<int, void>, "");
+        static_assert(!std::is_nothrow_swappable_with_v<const void, const volatile void>, "");
+
+    }
+    {
+        // test for presence of is_nothrow_swappable_with_v
+        static_assert(std::is_nothrow_swappable_with_v<int&, int&>, "");
+        static_assert(!std::is_nothrow_swappable_with_v<int&&, int&&>, "");
+    }
+}
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_polymorphic.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_polymorphic.pass.cpp
index b66e7a296f39..6ce1c0377526 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_polymorphic.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_polymorphic.pass.cpp
@@ -65,7 +65,7 @@ class Abstract
     virtual ~Abstract() = 0;
 };
 
-#if __has_feature(cxx_attributes) 
+#if TEST_STD_VER >= 11
 class Final final {
 };
 #else
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_signed.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_signed.pass.cpp
index 94bf7fb58041..745efd00895c 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_signed.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_signed.pass.cpp
@@ -50,6 +50,8 @@ public:
     ~Class();
 };
 
+struct A; // incomplete
+
 int main()
 {
     test_is_not_signed<void>();
@@ -61,6 +63,7 @@ int main()
     test_is_not_signed<char[]>();
     test_is_not_signed<bool>();
     test_is_not_signed<unsigned>();
+    test_is_not_signed<A>();
 
     test_is_signed<int>();
     test_is_signed<double>();
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable.pass.cpp
new file mode 100644
index 000000000000..b17ca76fd586
--- /dev/null
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable.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, c++11, c++14
+
+// type_traits
+
+// is_swappable
+
+#include <type_traits>
+#include <utility>
+#include <vector>
+#include "test_macros.h"
+
+namespace MyNS {
+
+// Make the test types non-copyable so that generic std::swap is not valid.
+struct A {
+  A(A const&) = delete;
+  A& operator=(A const&) = delete;
+};
+
+struct B {
+  B(B const&) = delete;
+  B& operator=(B const&) = delete;
+};
+
+struct C {};
+struct D {};
+
+void swap(A&, A&) {}
+
+void swap(A&, B&) {}
+void swap(B&, A&) {}
+
+void swap(A&, C&) {} // missing swap(C, A)
+void swap(D&, C&) {}
+
+struct M {
+  M(M const&) = delete;
+  M& operator=(M const&) = delete;
+};
+
+void swap(M&&, M&&) {}
+
+struct DeletedSwap {
+  friend void swap(DeletedSwap&, DeletedSwap&) = delete;
+};
+
+} // namespace MyNS
+
+namespace MyNS2 {
+
+struct AmbiguousSwap {};
+
+template <class T>
+void swap(T&, T&) {}
+
+} // end namespace MyNS2
+
+int main()
+{
+    using namespace MyNS;
+    {
+        // Test that is_swappable applies an lvalue reference to the type.
+        static_assert(std::is_swappable<A>::value, "");
+        static_assert(std::is_swappable<A&>::value, "");
+        static_assert(!std::is_swappable<M>::value, "");
+        static_assert(!std::is_swappable<M&&>::value, "");
+    }
+    static_assert(!std::is_swappable<B>::value, "");
+    static_assert(std::is_swappable<C>::value, "");
+    {
+        // test non-referencable types
+        static_assert(!std::is_swappable<void>::value, "");
+        static_assert(!std::is_swappable<int() const>::value, "");
+        static_assert(!std::is_swappable<int() &>::value, "");
+    }
+    {
+        // test that a deleted swap is correctly handled.
+        static_assert(!std::is_swappable<DeletedSwap>::value, "");
+    }
+    {
+        // test that a swap with ambiguous overloads is handled correctly.
+        static_assert(!std::is_swappable<MyNS2::AmbiguousSwap>::value, "");
+    }
+    {
+        // test for presence of is_swappable_v
+        static_assert(std::is_swappable_v<int>, "");
+        static_assert(!std::is_swappable_v<M>, "");
+    }
+}
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_include_order.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_include_order.pass.cpp
new file mode 100644
index 000000000000..c3ae1706f095
--- /dev/null
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_include_order.pass.cpp
@@ -0,0 +1,43 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// type_traits
+
+// is_swappable
+
+// IMPORTANT: The include order is part of the test. We want to pick up
+// the following definitions in this order:
+//   1) is_swappable, is_nothrow_swappable
+//   2) iter_swap, swap_ranges
+//   3) swap(T (&)[N], T (&)[N])
+// This test checks that (1) and (2) see forward declarations
+// for (3).
+#include <type_traits>
+#include <algorithm>
+#include <utility>
+
+#include "test_macros.h"
+
+int main()
+{
+    // Use a builtin type so we don't get ADL lookup.
+    typedef double T[17][29];
+    {
+        LIBCPP_STATIC_ASSERT(std::__is_swappable<T>::value, "");
+#if TEST_STD_VER > 14
+        static_assert(std::is_swappable_v<T>, "");
+#endif
+    }
+    {
+        T t1 = {};
+        T t2 = {};
+       std::iter_swap(t1, t2);
+       std::swap_ranges(t1, t1 + 17, t2);
+    }
+}
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_with.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_with.pass.cpp
new file mode 100644
index 000000000000..a049eab9a192
--- /dev/null
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_with.pass.cpp
@@ -0,0 +1,78 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11, c++14
+
+// type_traits
+
+// is_swappable_with
+
+#include <type_traits>
+#include <vector>
+#include "test_macros.h"
+
+namespace MyNS {
+
+struct A {
+  A(A const&) = delete;
+  A& operator=(A const&) = delete;
+};
+
+struct B {
+  B(B const&) = delete;
+  B& operator=(B const&) = delete;
+};
+
+struct C {};
+struct D {};
+
+void swap(A&, A&) {}
+
+void swap(A&, B&) {}
+void swap(B&, A&) {}
+
+void swap(A&, C&) {} // missing swap(C, A)
+void swap(D&, C&) {}
+
+struct M {};
+
+void swap(M&&, M&&) {}
+
+} // namespace MyNS
+
+int main()
+{
+    using namespace MyNS;
+    {
+        // Test that is_swappable_with doesn't apply an lvalue reference
+        // to the type. Instead it is up to the user.
+        static_assert(!std::is_swappable_with<int, int>::value, "");
+        static_assert(std::is_swappable_with<int&, int&>::value, "");
+        static_assert(std::is_swappable_with<M, M>::value, "");
+        static_assert(std::is_swappable_with<A&, A&>::value, "");
+    }
+    {
+        // test that heterogeneous swap is allowed only if both 'swap(A, B)' and
+        // 'swap(B, A)' are valid.
+        static_assert(std::is_swappable_with<A&, B&>::value, "");
+        static_assert(!std::is_swappable_with<A&, C&>::value, "");
+        static_assert(!std::is_swappable_with<D&, C&>::value, "");
+    }
+    {
+        // test that cv void is guarded against as required.
+        static_assert(!std::is_swappable_with_v<void, int>, "");
+        static_assert(!std::is_swappable_with_v<int, void>, "");
+        static_assert(!std::is_swappable_with_v<const void, const volatile void>, "");
+    }
+    {
+        // test for presence of is_swappable_with_v
+        static_assert(std::is_swappable_with_v<int&, int&>, "");
+        static_assert(!std::is_swappable_with_v<D&, C&>, "");
+    }
+}
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_assignable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_assignable.pass.cpp
index 3ebb9dba429d..a9b538b2dffc 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_assignable.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_assignable.pass.cpp
@@ -11,6 +11,8 @@
 
 // is_trivially_assignable
 
+// XFAIL: gcc-4.9
+
 #include <type_traits>
 #include "test_macros.h"
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_assignable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_assignable.pass.cpp
index 25429f5470e7..966573c9f0fe 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_assignable.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_assignable.pass.cpp
@@ -11,6 +11,8 @@
 
 // is_trivially_copy_assignable
 
+// XFAIL: gcc-4.9
+
 #include <type_traits>
 #include "test_macros.h"
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_constructible.pass.cpp
index 9556959e1262..2922f2276669 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_constructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_constructible.pass.cpp
@@ -11,6 +11,8 @@
 
 // is_trivially_copy_constructible
 
+// XFAIL: gcc-4.9
+
 #include <type_traits>
 #include "test_macros.h"
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copyable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copyable.pass.cpp
index c19a29ffb586..42ecdb3b896a 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copyable.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copyable.pass.cpp
@@ -11,6 +11,8 @@
 
 // is_trivially_copyable
 
+// XFAIL: gcc-4.9
+
 #include <type_traits>
 #include <cassert>
 #include "test_macros.h"
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp
index 9e2507067d2d..3372e615d71d 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp
@@ -11,6 +11,11 @@
 
 // is_trivially_destructible
 
+// Prevent warning when testing the Abstract test type.
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wdelete-non-virtual-dtor"
+#endif
+
 #include <type_traits>
 #include "test_macros.h"
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_assignable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_assignable.pass.cpp
index eca596ee1c19..9a27c73cdfd8 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_assignable.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_assignable.pass.cpp
@@ -11,6 +11,8 @@
 
 // is_trivially_move_assignable
 
+// XFAIL: gcc-4.9
+
 #include <type_traits>
 #include "test_macros.h"
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_constructible.pass.cpp
index 313da175f715..941ff31f89da 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_constructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_constructible.pass.cpp
@@ -11,6 +11,8 @@
 
 // is_trivially_move_constructible
 
+// XFAIL: gcc-4.9
+
 #include <type_traits>
 #include "test_macros.h"
 
@@ -60,7 +62,7 @@ struct A
     A(const A&);
 };
 
-#if __has_feature(cxx_defaulted_functions)
+#if TEST_STD_VER >= 11
 
 struct MoveOnly1
 {
@@ -89,7 +91,7 @@ int main()
     test_is_trivially_move_constructible<const int*>();
     test_is_trivially_move_constructible<bit_zero>();
 
-#if __has_feature(cxx_defaulted_functions)
+#if TEST_STD_VER >= 11
     static_assert(!std::is_trivially_move_constructible<MoveOnly1>::value, "");
     static_assert( std::is_trivially_move_constructible<MoveOnly2>::value, "");
 #endif
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_unsigned.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_unsigned.pass.cpp
index 9ca42432df16..376c7e005ce9 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_unsigned.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_unsigned.pass.cpp
@@ -50,6 +50,8 @@ public:
     ~Class();
 };
 
+struct A; // incomplete
+
 int main()
 {
     test_is_not_unsigned<void>();
@@ -61,6 +63,7 @@ int main()
     test_is_not_unsigned<char[]>();
     test_is_not_unsigned<int>();
     test_is_not_unsigned<double>();
+    test_is_not_unsigned<A>();
 
     test_is_unsigned<bool>();
     test_is_unsigned<unsigned>();
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_volatile.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_volatile.pass.cpp
index 36697a3f3eba..cc8d66ae6888 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_volatile.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_volatile.pass.cpp
@@ -29,6 +29,8 @@ void test_is_volatile()
 #endif
 }
 
+struct A; // incomplete
+
 int main()
 {
     test_is_volatile<void>();
@@ -39,6 +41,8 @@ int main()
     test_is_volatile<char[3]>();
     test_is_volatile<char[]>();
 
+    test_is_volatile<A>();
+
     static_assert(!std::is_volatile<int&>::value, "");
     static_assert(!std::is_volatile<volatile int&>::value, "");
 }
diff --git a/test/std/utilities/template.bitset/bitset.cons/char_ptr_ctor.pass.cpp b/test/std/utilities/template.bitset/bitset.cons/char_ptr_ctor.pass.cpp
index 9411435e29e8..ab623bb01f78 100644
--- a/test/std/utilities/template.bitset/bitset.cons/char_ptr_ctor.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.cons/char_ptr_ctor.pass.cpp
@@ -7,7 +7,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // template <class charT>
 //     explicit bitset(const charT* str,
 //                     typename basic_string<charT>::size_type n = basic_string<charT>::npos,
@@ -18,20 +17,19 @@
 #include <algorithm> // for 'min' and 'max'
 #include <stdexcept> // for 'invalid_argument'
 
-#pragma clang diagnostic ignored "-Wtautological-compare"
+#include "test_macros.h"
 
 template <std::size_t N>
 void test_char_pointer_ctor()
 {
     {
-    try
-    {
-        std::bitset<N> v("xxx1010101010xxxx");
-        assert(false);
-    }
-    catch (std::invalid_argument&)
-    {
-    }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+        try {
+            std::bitset<N> v("xxx1010101010xxxx");
+            assert(false);
+        }
+        catch (std::invalid_argument&) {}
+#endif
     }
 
     {
diff --git a/test/std/utilities/template.bitset/bitset.cons/default.pass.cpp b/test/std/utilities/template.bitset/bitset.cons/default.pass.cpp
index bd5ca7e08b2a..f4f8d390de08 100644
--- a/test/std/utilities/template.bitset/bitset.cons/default.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.cons/default.pass.cpp
@@ -12,19 +12,26 @@
 #include <bitset>
 #include <cassert>
 
-#pragma clang diagnostic ignored "-Wtautological-compare"
+#include "test_macros.h"
 
 template <std::size_t N>
 void test_default_ctor()
 {
     {
-    _LIBCPP_CONSTEXPR std::bitset<N> v1;
-    assert(v1.size() == N);
-    for (std::size_t i = 0; i < N; ++i)
-        assert(v1[i] == false);
+        TEST_CONSTEXPR std::bitset<N> v1;
+        assert(v1.size() == N);
+        for (std::size_t i = 0; i < N; ++i)
+            assert(v1[i] == false);
     }
+#if TEST_STD_VER >= 11
+    {
+        constexpr std::bitset<N> v1;
+        static_assert(v1.size() == N, "");
+    }
+#endif
 }
 
+
 int main()
 {
     test_default_ctor<0>();
diff --git a/test/std/utilities/template.bitset/bitset.cons/string_ctor.pass.cpp b/test/std/utilities/template.bitset/bitset.cons/string_ctor.pass.cpp
index b08720f57ee3..0e4793027c98 100644
--- a/test/std/utilities/template.bitset/bitset.cons/string_ctor.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.cons/string_ctor.pass.cpp
@@ -7,7 +7,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // test bitset(string, pos, n, zero, one);
 
 #include <bitset>
@@ -15,65 +14,60 @@
 #include <algorithm> // for 'min' and 'max'
 #include <stdexcept> // for 'invalid_argument'
 
-#pragma clang diagnostic ignored "-Wtautological-compare"
+#include "test_macros.h"
 
 template <std::size_t N>
 void test_string_ctor()
 {
+#ifndef TEST_HAS_NO_EXCEPTIONS
     {
-    try
-    {
-        std::string str("xxx1010101010xxxx");
-        std::bitset<N> v(str, str.size()+1, 10);
-        assert(false);
-    }
-    catch (std::out_of_range&)
-    {
-    }
+        try {
+            std::string str("xxx1010101010xxxx");
+            std::bitset<N> v(str, str.size()+1, 10);
+            assert(false);
+        }
+        catch (std::out_of_range&)
+        {
+        }
     }
-
-    {
-    try
     {
-        std::string str("xxx1010101010xxxx");
-        std::bitset<N> v(str, 2, 10);
-        assert(false);
+        try {
+            std::string str("xxx1010101010xxxx");
+            std::bitset<N> v(str, 2, 10);
+            assert(false);
+        }
+        catch (std::invalid_argument&)
+        {
+        }
     }
-    catch (std::invalid_argument&)
     {
+        try {
+            std::string str("xxxbababababaxxxx");
+            std::bitset<N> v(str, 2, 10, 'a', 'b');
+            assert(false);
+        }
+        catch (std::invalid_argument&)
+        {
+        }
     }
-    }
-
+#endif // TEST_HAS_NO_EXCEPTIONS
     {
-    std::string str("xxx1010101010xxxx");
-    std::bitset<N> v(str, 3, 10);
-    std::size_t M = std::min<std::size_t>(N, 10);
-    for (std::size_t i = 0; i < M; ++i)
-        assert(v[i] == (str[3 + M - 1 - i] == '1'));
-    for (std::size_t i = 10; i < N; ++i)
-        assert(v[i] == false);
+        std::string str("xxx1010101010xxxx");
+        std::bitset<N> v(str, 3, 10);
+        std::size_t M = std::min<std::size_t>(N, 10);
+        for (std::size_t i = 0; i < M; ++i)
+            assert(v[i] == (str[3 + M - 1 - i] == '1'));
+        for (std::size_t i = 10; i < N; ++i)
+            assert(v[i] == false);
     }
-
-    {
-    try
     {
         std::string str("xxxbababababaxxxx");
-        std::bitset<N> v(str, 2, 10, 'a', 'b');
-        assert(false);
-    }
-    catch (std::invalid_argument&)
-    {
-    }
-    }
-
-    {
-    std::string str("xxxbababababaxxxx");
-    std::bitset<N> v(str, 3, 10, 'a', 'b');
-    std::size_t M = std::min<std::size_t>(N, 10);
-    for (std::size_t i = 0; i < M; ++i)
-        assert(v[i] == (str[3 + M - 1 - i] == 'b'));
-    for (std::size_t i = 10; i < N; ++i)
-        assert(v[i] == false);
+        std::bitset<N> v(str, 3, 10, 'a', 'b');
+        std::size_t M = std::min<std::size_t>(N, 10);
+        for (std::size_t i = 0; i < M; ++i)
+            assert(v[i] == (str[3 + M - 1 - i] == 'b'));
+        for (std::size_t i = 10; i < N; ++i)
+            assert(v[i] == false);
     }
 }
 
diff --git a/test/std/utilities/template.bitset/bitset.cons/ull_ctor.pass.cpp b/test/std/utilities/template.bitset/bitset.cons/ull_ctor.pass.cpp
index f232447e08c3..1b121c5fb928 100644
--- a/test/std/utilities/template.bitset/bitset.cons/ull_ctor.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.cons/ull_ctor.pass.cpp
@@ -13,20 +13,26 @@
 #include <cassert>
 #include <algorithm> // for 'min' and 'max'
 
-#pragma clang diagnostic ignored "-Wtautological-compare"
+#include "test_macros.h"
 
 template <std::size_t N>
 void test_val_ctor()
 {
     {
-    _LIBCPP_CONSTEXPR std::bitset<N> v(0xAAAAAAAAAAAAAAAAULL);
-    assert(v.size() == N);
-    unsigned M = std::min<std::size_t>(N, 64);
-    for (std::size_t i = 0; i < M; ++i)
-        assert(v[i] == (i & 1));
-    for (std::size_t i = M; i < N; ++i)
-        assert(v[i] == false);
+        TEST_CONSTEXPR std::bitset<N> v(0xAAAAAAAAAAAAAAAAULL);
+        assert(v.size() == N);
+        unsigned M = std::min<std::size_t>(N, 64);
+        for (std::size_t i = 0; i < M; ++i)
+            assert(v[i] == (i & 1));
+        for (std::size_t i = M; i < N; ++i)
+            assert(v[i] == false);
     }
+#if TEST_STD_VER >= 11
+    {
+        constexpr std::bitset<N> v(0xAAAAAAAAAAAAAAAAULL);
+        static_assert(v.size() == N, "");
+    }
+#endif
 }
 
 int main()
diff --git a/test/std/utilities/template.bitset/bitset.hash/bitset.pass.cpp b/test/std/utilities/template.bitset/bitset.hash/bitset.pass.cpp
index 520f2e8757c2..bc65078911b2 100644
--- a/test/std/utilities/template.bitset/bitset.hash/bitset.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.hash/bitset.pass.cpp
@@ -16,12 +16,12 @@
 //     size_t operator()(T val) const;
 // };
 
-// Not very portable
-
 #include <bitset>
 #include <cassert>
 #include <type_traits>
 
+#include "test_macros.h"
+
 template <std::size_t N>
 void
 test()
@@ -32,7 +32,9 @@ test()
     static_assert((std::is_same<typename H::result_type, std::size_t>::value), "" );
     H h;
     T bs(static_cast<unsigned long long>(N));
-    assert(h(bs) == N);
+    const std::size_t result = h(bs);
+    LIBCPP_ASSERT(result == N);
+    ((void)result); // Prevent unused warning
 }
 
 int main()
diff --git a/test/std/utilities/template.bitset/bitset.members/count.pass.cpp b/test/std/utilities/template.bitset/bitset.members/count.pass.cpp
index fb9ce6422997..c8a14c9b6049 100644
--- a/test/std/utilities/template.bitset/bitset.members/count.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/count.pass.cpp
@@ -13,7 +13,9 @@
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
diff --git a/test/std/utilities/template.bitset/bitset.members/flip_all.pass.cpp b/test/std/utilities/template.bitset/bitset.members/flip_all.pass.cpp
index 6c4f5c699850..a25e5bd9da22 100644
--- a/test/std/utilities/template.bitset/bitset.members/flip_all.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/flip_all.pass.cpp
@@ -13,7 +13,9 @@
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
diff --git a/test/std/utilities/template.bitset/bitset.members/flip_one.pass.cpp b/test/std/utilities/template.bitset/bitset.members/flip_one.pass.cpp
index cffca68fb1ea..88ce8e943caf 100644
--- a/test/std/utilities/template.bitset/bitset.members/flip_one.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/flip_one.pass.cpp
@@ -14,8 +14,6 @@
 #include <cstdlib>
 #include <cassert>
 
-#pragma clang diagnostic ignored "-Wtautological-compare"
-
 template <std::size_t N>
 std::bitset<N>
 make_bitset()
diff --git a/test/std/utilities/template.bitset/bitset.members/index.pass.cpp b/test/std/utilities/template.bitset/bitset.members/index.pass.cpp
index b96aaa51ab8f..02e58a7890c5 100644
--- a/test/std/utilities/template.bitset/bitset.members/index.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/index.pass.cpp
@@ -13,7 +13,9 @@
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
diff --git a/test/std/utilities/template.bitset/bitset.members/index_const.pass.cpp b/test/std/utilities/template.bitset/bitset.members/index_const.pass.cpp
index e3c28c693576..870a504c2d75 100644
--- a/test/std/utilities/template.bitset/bitset.members/index_const.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/index_const.pass.cpp
@@ -13,7 +13,9 @@
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
diff --git a/test/std/utilities/template.bitset/bitset.members/left_shift.pass.cpp b/test/std/utilities/template.bitset/bitset.members/left_shift.pass.cpp
index 7fe9fa72e924..57b77d2570d5 100644
--- a/test/std/utilities/template.bitset/bitset.members/left_shift.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/left_shift.pass.cpp
@@ -13,7 +13,9 @@
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
diff --git a/test/std/utilities/template.bitset/bitset.members/left_shift_eq.pass.cpp b/test/std/utilities/template.bitset/bitset.members/left_shift_eq.pass.cpp
index bed3e28ece81..3adab77b4131 100644
--- a/test/std/utilities/template.bitset/bitset.members/left_shift_eq.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/left_shift_eq.pass.cpp
@@ -13,7 +13,9 @@
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
diff --git a/test/std/utilities/template.bitset/bitset.members/not_all.pass.cpp b/test/std/utilities/template.bitset/bitset.members/not_all.pass.cpp
index 2f8f7111f5a1..d9fbb3e11dad 100644
--- a/test/std/utilities/template.bitset/bitset.members/not_all.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/not_all.pass.cpp
@@ -13,7 +13,9 @@
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
diff --git a/test/std/utilities/template.bitset/bitset.members/op_and_eq.pass.cpp b/test/std/utilities/template.bitset/bitset.members/op_and_eq.pass.cpp
index b599ec398b30..64ca15fda137 100644
--- a/test/std/utilities/template.bitset/bitset.members/op_and_eq.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/op_and_eq.pass.cpp
@@ -13,7 +13,9 @@
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
diff --git a/test/std/utilities/template.bitset/bitset.members/op_eq_eq.pass.cpp b/test/std/utilities/template.bitset/bitset.members/op_eq_eq.pass.cpp
index 5f6cf3d0a30c..24761c628c03 100644
--- a/test/std/utilities/template.bitset/bitset.members/op_eq_eq.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/op_eq_eq.pass.cpp
@@ -16,7 +16,9 @@
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
diff --git a/test/std/utilities/template.bitset/bitset.members/op_or_eq.pass.cpp b/test/std/utilities/template.bitset/bitset.members/op_or_eq.pass.cpp
index 6e63879890a6..f2880f67ab6e 100644
--- a/test/std/utilities/template.bitset/bitset.members/op_or_eq.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/op_or_eq.pass.cpp
@@ -13,7 +13,9 @@
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
diff --git a/test/std/utilities/template.bitset/bitset.members/op_xor_eq.pass.cpp b/test/std/utilities/template.bitset/bitset.members/op_xor_eq.pass.cpp
index e68a641cadc6..420996759d0d 100644
--- a/test/std/utilities/template.bitset/bitset.members/op_xor_eq.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/op_xor_eq.pass.cpp
@@ -13,7 +13,9 @@
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
diff --git a/test/std/utilities/template.bitset/bitset.members/reset_all.pass.cpp b/test/std/utilities/template.bitset/bitset.members/reset_all.pass.cpp
index ee44d92c43b8..eed25e27448d 100644
--- a/test/std/utilities/template.bitset/bitset.members/reset_all.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/reset_all.pass.cpp
@@ -12,7 +12,9 @@
 #include <bitset>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 void test_reset_all()
diff --git a/test/std/utilities/template.bitset/bitset.members/reset_one.pass.cpp b/test/std/utilities/template.bitset/bitset.members/reset_one.pass.cpp
index 6de256b00cc5..f01d35b9a33c 100644
--- a/test/std/utilities/template.bitset/bitset.members/reset_one.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/reset_one.pass.cpp
@@ -13,9 +13,6 @@
 #include <bitset>
 #include <cassert>
 
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wtautological-compare"
-
 template <std::size_t N>
 void test_reset_one()
 {
diff --git a/test/std/utilities/template.bitset/bitset.members/right_shift.pass.cpp b/test/std/utilities/template.bitset/bitset.members/right_shift.pass.cpp
index 87fcc281fa26..180fa84f4488 100644
--- a/test/std/utilities/template.bitset/bitset.members/right_shift.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/right_shift.pass.cpp
@@ -13,7 +13,9 @@
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
diff --git a/test/std/utilities/template.bitset/bitset.members/right_shift_eq.pass.cpp b/test/std/utilities/template.bitset/bitset.members/right_shift_eq.pass.cpp
index 1dd89c1844b9..47494fc459a5 100644
--- a/test/std/utilities/template.bitset/bitset.members/right_shift_eq.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/right_shift_eq.pass.cpp
@@ -13,7 +13,9 @@
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
diff --git a/test/std/utilities/template.bitset/bitset.members/set_all.pass.cpp b/test/std/utilities/template.bitset/bitset.members/set_all.pass.cpp
index 56454a84f113..e5c3e25352cc 100644
--- a/test/std/utilities/template.bitset/bitset.members/set_all.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/set_all.pass.cpp
@@ -12,7 +12,9 @@
 #include <bitset>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 void test_set_all()
diff --git a/test/std/utilities/template.bitset/bitset.members/test.pass.cpp b/test/std/utilities/template.bitset/bitset.members/test.pass.cpp
index ce594d0ae891..161afd11c291 100644
--- a/test/std/utilities/template.bitset/bitset.members/test.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/test.pass.cpp
@@ -14,8 +14,6 @@
 #include <cstdlib>
 #include <cassert>
 
-#pragma clang diagnostic ignored "-Wtautological-compare"
-
 template <std::size_t N>
 std::bitset<N>
 make_bitset()
diff --git a/test/std/utilities/template.bitset/bitset.members/to_string.pass.cpp b/test/std/utilities/template.bitset/bitset.members/to_string.pass.cpp
index b65794097470..5b2958cca523 100644
--- a/test/std/utilities/template.bitset/bitset.members/to_string.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/to_string.pass.cpp
@@ -26,7 +26,9 @@
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
diff --git a/test/std/utilities/template.bitset/bitset.operators/op_and.pass.cpp b/test/std/utilities/template.bitset/bitset.operators/op_and.pass.cpp
index 751cee69102a..80792d919ccf 100644
--- a/test/std/utilities/template.bitset/bitset.operators/op_and.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.operators/op_and.pass.cpp
@@ -13,7 +13,9 @@
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
diff --git a/test/std/utilities/template.bitset/bitset.operators/op_not.pass.cpp b/test/std/utilities/template.bitset/bitset.operators/op_not.pass.cpp
index fda5e5cda8ee..65a7004acb86 100644
--- a/test/std/utilities/template.bitset/bitset.operators/op_not.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.operators/op_not.pass.cpp
@@ -13,7 +13,9 @@
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
diff --git a/test/std/utilities/template.bitset/bitset.operators/op_or.pass.cpp b/test/std/utilities/template.bitset/bitset.operators/op_or.pass.cpp
index 067f868215be..dcabaa4a9a4d 100644
--- a/test/std/utilities/template.bitset/bitset.operators/op_or.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.operators/op_or.pass.cpp
@@ -13,7 +13,9 @@
 #include <cstdlib>
 #include <cassert>
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
 
 template <std::size_t N>
 std::bitset<N>
diff --git a/test/std/utilities/time/date.time/ctime.pass.cpp b/test/std/utilities/time/date.time/ctime.pass.cpp
index d0a838e0c271..b9e19af32952 100644
--- a/test/std/utilities/time/date.time/ctime.pass.cpp
+++ b/test/std/utilities/time/date.time/ctime.pass.cpp
@@ -21,11 +21,15 @@
 int main()
 {
     std::clock_t c = 0;
-    ((void)c); // avoid unused warning
     std::size_t s = 0;
     std::time_t t = 0;
-    std::tm tm = {0};
+    std::tm tm = {};
     char str[3];
+    ((void)c); // Prevent unused warning
+    ((void)s); // Prevent unused warning
+    ((void)t); // Prevent unused warning
+    ((void)tm); // Prevent unused warning
+    ((void)str); // Prevent unused warning
     static_assert((std::is_same<decltype(std::clock()), std::clock_t>::value), "");
     static_assert((std::is_same<decltype(std::difftime(t,t)), double>::value), "");
     static_assert((std::is_same<decltype(std::mktime(&tm)), std::time_t>::value), "");
diff --git a/test/std/utilities/time/time.clock/time.clock.hires/consistency.pass.cpp b/test/std/utilities/time/time.clock/time.clock.hires/consistency.pass.cpp
index 2e3acbc52b11..b6b3aeea94f8 100644
--- a/test/std/utilities/time/time.clock/time.clock.hires/consistency.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.hires/consistency.pass.cpp
@@ -12,6 +12,10 @@
 // XFAIL: with_system_cxx_lib=x86_64-apple-darwin11
 // XFAIL: with_system_cxx_lib=x86_64-apple-darwin12
 
+// Due to C++17 inline variables ASAN flags this test as containing an ODR
+// violation because Clock::is_steady is defined in both the dylib and this TU.
+// UNSUPPORTED: asan
+
 // <chrono>
 
 // high_resolution_clock
diff --git a/test/std/utilities/time/time.clock/time.clock.steady/consistency.pass.cpp b/test/std/utilities/time/time.clock/time.clock.steady/consistency.pass.cpp
index 0e0b83b2f244..6302ce6efb34 100644
--- a/test/std/utilities/time/time.clock/time.clock.steady/consistency.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.steady/consistency.pass.cpp
@@ -13,6 +13,10 @@
 // XFAIL: with_system_cxx_lib=x86_64-apple-darwin12
 // UNSUPPORTED: libcpp-has-no-monotonic-clock
 
+// Due to C++17 inline variables ASAN flags this test as containing an ODR
+// violation because Clock::is_steady is defined in both the dylib and this TU.
+// UNSUPPORTED: asan
+
 // <chrono>
 
 // steady_clock
diff --git a/test/std/utilities/time/time.clock/time.clock.system/consistency.pass.cpp b/test/std/utilities/time/time.clock/time.clock.system/consistency.pass.cpp
index e277d4e67dc7..cfbe9bd57032 100644
--- a/test/std/utilities/time/time.clock/time.clock.system/consistency.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.system/consistency.pass.cpp
@@ -12,6 +12,10 @@
 // XFAIL: with_system_cxx_lib=x86_64-apple-darwin11
 // XFAIL: with_system_cxx_lib=x86_64-apple-darwin12
 
+// Due to C++17 inline variables ASAN flags this test as containing an ODR
+// violation because Clock::is_steady is defined in both the dylib and this TU.
+// UNSUPPORTED: asan
+
 // <chrono>
 
 // system_clock
diff --git a/test/std/utilities/time/time.duration/time.duration.alg/abs.pass.cpp b/test/std/utilities/time/time.duration/time.duration.alg/abs.pass.cpp
index ec32c37a9423..30ea029b7ef4 100644
--- a/test/std/utilities/time/time.duration/time.duration.alg/abs.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.alg/abs.pass.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03, c++11, c++14
+// UNSUPPORTED: c++98, c++03, c++11, c++14
 
 // <chrono>
 
diff --git a/test/std/utilities/time/time.duration/time.duration.cast/ceil.pass.cpp b/test/std/utilities/time/time.duration/time.duration.cast/ceil.pass.cpp
index 6fb73b97db17..8d7623c85e19 100644
--- a/test/std/utilities/time/time.duration/time.duration.cast/ceil.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cast/ceil.pass.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03, c++11, c++14
+// UNSUPPORTED: c++98, c++03, c++11, c++14
 
 // <chrono>
 
diff --git a/test/std/utilities/time/time.duration/time.duration.cast/floor.pass.cpp b/test/std/utilities/time/time.duration/time.duration.cast/floor.pass.cpp
index 57929dd91228..38db42a84ced 100644
--- a/test/std/utilities/time/time.duration/time.duration.cast/floor.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cast/floor.pass.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03, c++11, c++14
+// UNSUPPORTED: c++98, c++03, c++11, c++14
 // <chrono>
 
 // floor
diff --git a/test/std/utilities/time/time.duration/time.duration.cast/round.pass.cpp b/test/std/utilities/time/time.duration/time.duration.cast/round.pass.cpp
index e50b85c991a2..2f9689007dfd 100644
--- a/test/std/utilities/time/time.duration/time.duration.cast/round.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cast/round.pass.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03, c++11, c++14
+// UNSUPPORTED: c++98, c++03, c++11, c++14
 // <chrono>
 
 // round
diff --git a/test/std/utilities/time/time.duration/time.duration.literals/literals.pass.cpp b/test/std/utilities/time/time.duration/time.duration.literals/literals.pass.cpp
index 48324ae83651..d5c0207c0ee7 100644
--- a/test/std/utilities/time/time.duration/time.duration.literals/literals.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.literals/literals.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <chrono>
 
 #include <chrono>
@@ -15,7 +16,6 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11 
     using namespace std::literals::chrono_literals;
 
 //    Make sure the types are right
@@ -25,12 +25,12 @@ int main()
     static_assert ( std::is_same<decltype( 3ms  ), std::chrono::milliseconds>::value, "" );
     static_assert ( std::is_same<decltype( 3us  ), std::chrono::microseconds>::value, "" );
     static_assert ( std::is_same<decltype( 3ns  ), std::chrono::nanoseconds>::value, "" );
-    
+
     std::chrono::hours h = 4h;
     assert ( h == std::chrono::hours(4));
     auto h2 = 4.0h;
     assert ( h == h2 );
-    
+
     std::chrono::minutes min = 36min;
     assert ( min == std::chrono::minutes(36));
     auto min2 = 36.0min;
@@ -55,5 +55,4 @@ int main()
     assert ( ns == std::chrono::nanoseconds(645));
     auto ns2 = 645.ns;
     assert ( ns == ns2 );
-#endif
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.literals/literals1.fail.cpp b/test/std/utilities/time/time.duration/time.duration.literals/literals1.fail.cpp
index 46aaa30e51e4..52208cb54d6d 100644
--- a/test/std/utilities/time/time.duration/time.duration.literals/literals1.fail.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.literals/literals1.fail.cpp
@@ -7,15 +7,13 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
 #include <chrono>
 #include <cassert>
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11 
     std::chrono::hours h  = 4h;  // should fail w/conversion operator not found
-#else
-#error
-#endif
 }
 
diff --git a/test/std/utilities/time/time.duration/time.duration.literals/literals1.pass.cpp b/test/std/utilities/time/time.duration/time.duration.literals/literals1.pass.cpp
index 574f9bcce874..5e59e1153787 100644
--- a/test/std/utilities/time/time.duration/time.duration.literals/literals1.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.literals/literals1.pass.cpp
@@ -7,19 +7,20 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
 #include <chrono>
 #include <cassert>
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11 
     using namespace std::chrono;
 
     hours h = 4h;
     assert ( h == hours(4));
     auto h2 = 4.0h;
     assert ( h == h2 );
-    
+
     minutes min = 36min;
     assert ( min == minutes(36));
     auto min2 = 36.0min;
@@ -44,5 +45,4 @@ int main()
     assert ( ns == nanoseconds(645));
     auto ns2 = 645.ns;
     assert ( ns == ns2 );
-#endif
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.literals/literals2.fail.cpp b/test/std/utilities/time/time.duration/time.duration.literals/literals2.fail.cpp
index 17358e589f4f..f190d7863066 100644
--- a/test/std/utilities/time/time.duration/time.duration.literals/literals2.fail.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.literals/literals2.fail.cpp
@@ -7,16 +7,14 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
 #include <chrono>
 #include <cassert>
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11 
     using std::chrono::hours;
 
     hours foo  =  4h;  // should fail w/conversion operator not found
-#else
-#error
-#endif
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.literals/literals2.pass.cpp b/test/std/utilities/time/time.duration/time.duration.literals/literals2.pass.cpp
index e37bc6e67961..282b1c6572e2 100644
--- a/test/std/utilities/time/time.duration/time.duration.literals/literals2.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.literals/literals2.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <chrono>
 
 #include <chrono>
@@ -15,14 +16,13 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11 
     using namespace std::literals;
 
     std::chrono::hours h = 4h;
     assert ( h == std::chrono::hours(4));
     auto h2 = 4.0h;
     assert ( h == h2 );
-    
+
     std::chrono::minutes min = 36min;
     assert ( min == std::chrono::minutes(36));
     auto min2 = 36.0min;
@@ -47,5 +47,4 @@ int main()
     assert ( ns == std::chrono::nanoseconds(645));
     auto ns2 = 645.ns;
     assert ( ns == ns2 );
-#endif
 }
diff --git a/test/std/utilities/time/time.point/time.point.cast/ceil.pass.cpp b/test/std/utilities/time/time.point/time.point.cast/ceil.pass.cpp
index 379929c7f2d8..e6e7c053885a 100644
--- a/test/std/utilities/time/time.point/time.point.cast/ceil.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.cast/ceil.pass.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03, c++11, c++14
+// UNSUPPORTED: c++98, c++03, c++11, c++14
 // <chrono>
 
 // ceil
diff --git a/test/std/utilities/time/time.point/time.point.cast/floor.pass.cpp b/test/std/utilities/time/time.point/time.point.cast/floor.pass.cpp
index d0a908fa932a..efd2d9e25cd7 100644
--- a/test/std/utilities/time/time.point/time.point.cast/floor.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.cast/floor.pass.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03, c++11, c++14
+// UNSUPPORTED: c++98, c++03, c++11, c++14
 // <chrono>
 
 // floor
diff --git a/test/std/utilities/time/time.point/time.point.cast/round.pass.cpp b/test/std/utilities/time/time.point/time.point.cast/round.pass.cpp
index ab8bf3a75e79..b5d16cf11d98 100644
--- a/test/std/utilities/time/time.point/time.point.cast/round.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.cast/round.pass.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03, c++11, c++14
+// UNSUPPORTED: c++98, c++03, c++11, c++14
 // <chrono>
 
 // round
diff --git a/test/std/utilities/time/time.point/time.point.comparisons/op_equal.pass.cpp b/test/std/utilities/time/time.point/time.point.comparisons/op_equal.pass.cpp
index fbd3a1386d35..a37bb266a0a9 100644
--- a/test/std/utilities/time/time.point/time.point.comparisons/op_equal.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.comparisons/op_equal.pass.cpp
@@ -54,7 +54,7 @@ int main()
     assert(!(t1 == t2));
     assert( (t1 != t2));
     }
-    
+
 #if _LIBCPP_STD_VER > 11
     {
     constexpr T1 t1(Duration1(3));
diff --git a/test/std/utilities/time/time.traits/time.traits.is_fp/treat_as_floating_point.pass.cpp b/test/std/utilities/time/time.traits/time.traits.is_fp/treat_as_floating_point.pass.cpp
index f9ddc87a7a14..faacb573d74b 100644
--- a/test/std/utilities/time/time.traits/time.traits.is_fp/treat_as_floating_point.pass.cpp
+++ b/test/std/utilities/time/time.traits/time.traits.is_fp/treat_as_floating_point.pass.cpp
@@ -14,6 +14,8 @@
 #include <chrono>
 #include <type_traits>
 
+#include "test_macros.h"
+
 template <class T>
 void
 test()
@@ -21,8 +23,8 @@ test()
     static_assert((std::is_base_of<std::is_floating_point<T>,
                                    std::chrono::treat_as_floating_point<T> >::value), "");
 #if TEST_STD_VER > 14
-    static_assert((std::is_base_of<std::is_floating_point<T>,
-                                   std::chrono::treat_as_floating_point_v<T> >), "");
+    static_assert(std::is_floating_point<T>::value ==
+                                  std::chrono::treat_as_floating_point_v<T>, "");
 #endif
 }
 
diff --git a/test/std/utilities/tuple/tuple.general/tuple.smartptr.pass.cpp b/test/std/utilities/tuple/tuple.general/tuple.smartptr.pass.cpp
index 1d8be420d837..d1b974c50753 100644
--- a/test/std/utilities/tuple/tuple.general/tuple.smartptr.pass.cpp
+++ b/test/std/utilities/tuple/tuple.general/tuple.smartptr.pass.cpp
@@ -21,18 +21,13 @@ int main () {
     std::tuple<std::unique_ptr<char>> up;
     std::tuple<std::shared_ptr<char>> sp;
     std::tuple<std::weak_ptr  <char>> wp;
-//     std::tuple<std::auto_ptr  <char>> ap;
     }
     {
     std::tuple<std::unique_ptr<char[]>> up;
     std::tuple<std::shared_ptr<char[]>> sp;
     std::tuple<std::weak_ptr  <char[]>> wp;
-//     std::tuple<std::auto_ptr  <char[]>> ap;
     }
-    {
-    std::tuple<std::unique_ptr<char[5]>> up;
-    std::tuple<std::shared_ptr<char[5]>> sp;
-    std::tuple<std::weak_ptr  <char[5]>> wp;
-//     std::tuple<std::auto_ptr  <char[5]>> ap;
-    }
-}
\ No newline at end of file
+    // Smart pointers of type 'T[N]' are not tested here since they are not
+    // supported by the standard nor by libc++'s implementation.
+    // See http://reviews.llvm.org/D21320 for more information.
+}
diff --git a/test/std/utilities/tuple/tuple.tuple/TupleFunction.pass.cpp b/test/std/utilities/tuple/tuple.tuple/TupleFunction.pass.cpp
index df5fdff511e3..ce6dcf811e46 100644
--- a/test/std/utilities/tuple/tuple.tuple/TupleFunction.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/TupleFunction.pass.cpp
@@ -9,7 +9,9 @@
 
 // This is for bugs 18853 and 19118
 
-#if __cplusplus >= 201103L
+#include "test_macros.h"
+
+#if TEST_STD_VER >= 11
 
 #include <tuple>
 #include <functional>
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply.pass.cpp
new file mode 100644
index 000000000000..2e821945d09a
--- /dev/null
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply.pass.cpp
@@ -0,0 +1,275 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11, c++14
+
+// <tuple>
+
+// template <class F, class T> constexpr decltype(auto) apply(F &&, T &&)
+
+// Test with different ref/ptr/cv qualified argument types.
+
+#include <tuple>
+#include <array>
+#include <utility>
+#include <cassert>
+
+#include "test_macros.h"
+#include "type_id.h"
+
+// std::array is explicitly allowed to be initialized with A a = { init-list };.
+// Disable the missing braces warning for this reason.
+#include "disable_missing_braces_warning.h"
+
+
+constexpr int constexpr_sum_fn() { return 0; }
+
+template <class ...Ints>
+constexpr int constexpr_sum_fn(int x1, Ints... rest) { return x1 + constexpr_sum_fn(rest...); }
+
+struct ConstexprSumT {
+  constexpr ConstexprSumT() = default;
+  template <class ...Ints>
+  constexpr int operator()(Ints... values) const {
+      return constexpr_sum_fn(values...);
+  }
+};
+
+
+void test_constexpr_evaluation()
+{
+    constexpr ConstexprSumT sum_obj{};
+    {
+        using Tup = std::tuple<>;
+        using Fn = int(&)();
+        constexpr Tup t;
+        static_assert(std::apply(static_cast<Fn>(constexpr_sum_fn), t) == 0, "");
+        static_assert(std::apply(sum_obj, t) == 0, "");
+    }
+    {
+        using Tup = std::tuple<int>;
+        using Fn = int(&)(int);
+        constexpr Tup t(42);
+        static_assert(std::apply(static_cast<Fn>(constexpr_sum_fn), t) == 42, "");
+        static_assert(std::apply(sum_obj, t) == 42, "");
+    }
+    {
+        using Tup = std::tuple<int, long>;
+        using Fn = int(&)(int, int);
+        constexpr Tup t(42, 101);
+        static_assert(std::apply(static_cast<Fn>(constexpr_sum_fn), t) == 143, "");
+        static_assert(std::apply(sum_obj, t) == 143, "");
+    }
+    {
+        using Tup = std::pair<int, long>;
+        using Fn = int(&)(int, int);
+        constexpr Tup t(42, 101);
+        static_assert(std::apply(static_cast<Fn>(constexpr_sum_fn), t) == 143, "");
+        static_assert(std::apply(sum_obj, t) == 143, "");
+    }
+    {
+        using Tup = std::tuple<int, long, int>;
+        using Fn = int(&)(int, int, int);
+        constexpr Tup t(42, 101, -1);
+        static_assert(std::apply(static_cast<Fn>(constexpr_sum_fn), t) == 142, "");
+        static_assert(std::apply(sum_obj, t) == 142, "");
+    }
+    {
+        using Tup = std::array<int, 3>;
+        using Fn = int(&)(int, int, int);
+        constexpr Tup t = {42, 101, -1};
+        static_assert(std::apply(static_cast<Fn>(constexpr_sum_fn), t) == 142, "");
+        static_assert(std::apply(sum_obj, t) == 142, "");
+    }
+}
+
+
+enum CallQuals {
+  CQ_None,
+  CQ_LValue,
+  CQ_ConstLValue,
+  CQ_RValue,
+  CQ_ConstRValue
+};
+
+template <class Tuple>
+struct CallInfo {
+  CallQuals quals;
+  TypeID const* arg_types;
+  Tuple args;
+
+  template <class ...Args>
+  CallInfo(CallQuals q, Args&&... xargs)
+      : quals(q), arg_types(&makeArgumentID<Args&&...>()), args(std::forward<Args>(xargs)...)
+  {}
+};
+
+template <class ...Args>
+inline CallInfo<decltype(std::forward_as_tuple(std::declval<Args>()...))>
+makeCallInfo(CallQuals quals, Args&&... args) {
+    return {quals, std::forward<Args>(args)...};
+}
+
+struct TrackedCallable {
+
+  TrackedCallable() = default;
+
+  template <class ...Args> auto operator()(Args&&... xargs) &
+  { return makeCallInfo(CQ_LValue, std::forward<Args>(xargs)...); }
+
+  template <class ...Args> auto operator()(Args&&... xargs) const&
+  { return makeCallInfo(CQ_ConstLValue, std::forward<Args>(xargs)...); }
+
+  template <class ...Args> auto operator()(Args&&... xargs) &&
+  { return makeCallInfo(CQ_RValue, std::forward<Args>(xargs)...); }
+
+  template <class ...Args> auto operator()(Args&&... xargs) const&&
+  { return makeCallInfo(CQ_ConstRValue, std::forward<Args>(xargs)...); }
+};
+
+template <class ...ExpectArgs, class Tuple>
+void check_apply_quals_and_types(Tuple&& t) {
+    TypeID const* const expect_args = &makeArgumentID<ExpectArgs...>();
+    TrackedCallable obj;
+    TrackedCallable const& cobj = obj;
+    {
+        auto ret = std::apply(obj, std::forward<Tuple>(t));
+        assert(ret.quals == CQ_LValue);
+        assert(ret.arg_types == expect_args);
+        assert(ret.args == t);
+    }
+    {
+        auto ret = std::apply(cobj, std::forward<Tuple>(t));
+        assert(ret.quals == CQ_ConstLValue);
+        assert(ret.arg_types == expect_args);
+        assert(ret.args == t);
+    }
+    {
+        auto ret = std::apply(std::move(obj), std::forward<Tuple>(t));
+        assert(ret.quals == CQ_RValue);
+        assert(ret.arg_types == expect_args);
+        assert(ret.args == t);
+    }
+    {
+        auto ret = std::apply(std::move(cobj), std::forward<Tuple>(t));
+        assert(ret.quals == CQ_ConstRValue);
+        assert(ret.arg_types == expect_args);
+        assert(ret.args == t);
+    }
+}
+
+void test_call_quals_and_arg_types()
+{
+    TrackedCallable obj;
+    using Tup = std::tuple<int, int const&, unsigned&&>;
+    const int x = 42;
+    unsigned y = 101;
+    Tup t(-1, x, std::move(y));
+    Tup const& ct = t;
+    check_apply_quals_and_types<int&, int const&, unsigned&>(t);
+    check_apply_quals_and_types<int const&, int const&, unsigned&>(ct);
+    check_apply_quals_and_types<int&&, int const&, unsigned&&>(std::move(t));
+    check_apply_quals_and_types<int const&&, int const&, unsigned&&>(std::move(ct));
+}
+
+
+struct NothrowMoveable {
+  NothrowMoveable() noexcept = default;
+  NothrowMoveable(NothrowMoveable const&) noexcept(false) {}
+  NothrowMoveable(NothrowMoveable&&) noexcept {}
+};
+
+template <bool IsNoexcept>
+struct TestNoexceptCallable {
+  template <class ...Args>
+  NothrowMoveable operator()(Args...) const noexcept(IsNoexcept) { return {}; }
+};
+
+void test_noexcept()
+{
+    TestNoexceptCallable<true> nec;
+    TestNoexceptCallable<false> tc;
+    {
+        // test that the functions noexcept-ness is propagated
+        using Tup = std::tuple<int, const char*, long>;
+        Tup t;
+        ASSERT_NOEXCEPT(std::apply(nec, t));
+        ASSERT_NOT_NOEXCEPT(std::apply(tc, t));
+    }
+    {
+        // test that the noexcept-ness of the argument conversions is checked.
+        using Tup = std::tuple<NothrowMoveable, int>;
+        Tup t;
+        ASSERT_NOT_NOEXCEPT(std::apply(nec, t));
+        ASSERT_NOEXCEPT(std::apply(nec, std::move(t)));
+    }
+}
+
+namespace ReturnTypeTest {
+    static int my_int = 42;
+
+    template <int N> struct index {};
+
+    void f(index<0>) {}
+
+    int f(index<1>) { return 0; }
+
+    int & f(index<2>) { return static_cast<int &>(my_int); }
+    int const & f(index<3>) { return static_cast<int const &>(my_int); }
+    int volatile & f(index<4>) { return static_cast<int volatile &>(my_int); }
+    int const volatile & f(index<5>) { return static_cast<int const volatile &>(my_int); }
+
+    int && f(index<6>) { return static_cast<int &&>(my_int); }
+    int const && f(index<7>) { return static_cast<int const &&>(my_int); }
+    int volatile && f(index<8>) { return static_cast<int volatile &&>(my_int); }
+    int const volatile && f(index<9>) { return static_cast<int const volatile &&>(my_int); }
+
+    int * f(index<10>) { return static_cast<int *>(&my_int); }
+    int const * f(index<11>) { return static_cast<int const *>(&my_int); }
+    int volatile * f(index<12>) { return static_cast<int volatile *>(&my_int); }
+    int const volatile * f(index<13>) { return static_cast<int const volatile *>(&my_int); }
+
+    template <int Func, class Expect>
+    void test()
+    {
+        using RawInvokeResult = decltype(f(index<Func>{}));
+        static_assert(std::is_same<RawInvokeResult, Expect>::value, "");
+        using FnType = RawInvokeResult (*) (index<Func>);
+        FnType fn = f;
+        std::tuple<index<Func>> t; ((void)t);
+        using InvokeResult = decltype(std::apply(fn, t));
+        static_assert(std::is_same<InvokeResult, Expect>::value, "");
+    }
+} // end namespace ReturnTypeTest
+
+void test_return_type()
+{
+    using ReturnTypeTest::test;
+    test<0, void>();
+    test<1, int>();
+    test<2, int &>();
+    test<3, int const &>();
+    test<4, int volatile &>();
+    test<5, int const volatile &>();
+    test<6, int &&>();
+    test<7, int const &&>();
+    test<8, int volatile &&>();
+    test<9, int const volatile &&>();
+    test<10, int *>();
+    test<11, int const *>();
+    test<12, int volatile *>();
+    test<13, int const volatile *>();
+}
+
+int main() {
+    test_constexpr_evaluation();
+    test_call_quals_and_arg_types();
+    test_return_type();
+    test_noexcept();
+}
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply_extended_types.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply_extended_types.pass.cpp
new file mode 100644
index 000000000000..02d7fe43e9cd
--- /dev/null
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply_extended_types.pass.cpp
@@ -0,0 +1,426 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11, c++14
+
+// <tuple>
+
+// template <class F, class T> constexpr decltype(auto) apply(F &&, T &&)
+
+// Testing extended function types. The extended function types are those
+// named by INVOKE but that are not actual callable objects. These include
+// bullets 1-4 of invoke.
+
+#include <tuple>
+#include <array>
+#include <utility>
+#include <cassert>
+
+// std::array is explicitly allowed to be initialized with A a = { init-list };.
+// Disable the missing braces warning for this reason.
+#include "disable_missing_braces_warning.h"
+
+int count = 0;
+
+struct A_int_0
+{
+    A_int_0() : obj1(0){}
+    A_int_0(int x) : obj1(x) {}
+    int mem1() { return ++count; }
+    int mem2() const { return ++count; }
+    int const obj1;
+};
+
+struct A_int_1
+{
+    A_int_1() {}
+    A_int_1(int) {}
+    int mem1(int x) { return count += x; }
+    int mem2(int x) const { return count += x; }
+};
+
+struct A_int_2
+{
+    A_int_2() {}
+    A_int_2(int) {}
+    int mem1(int x, int y) { return count += (x + y); }
+    int mem2(int x, int y) const { return count += (x + y); }
+};
+
+template <class A>
+struct A_wrap
+{
+    A_wrap() {}
+    A_wrap(int x) : m_a(x) {}
+    A & operator*() { return m_a; }
+    A const & operator*() const { return m_a; }
+    A m_a;
+};
+
+typedef A_wrap<A_int_0> A_wrap_0;
+typedef A_wrap<A_int_1> A_wrap_1;
+typedef A_wrap<A_int_2> A_wrap_2;
+
+
+template <class A>
+struct A_base : public A
+{
+    A_base() : A() {}
+    A_base(int x) : A(x) {}
+};
+
+typedef A_base<A_int_0> A_base_0;
+typedef A_base<A_int_1> A_base_1;
+typedef A_base<A_int_2> A_base_2;
+
+
+template <
+    class Tuple, class ConstTuple
+  , class TuplePtr, class ConstTuplePtr
+  , class TupleWrap, class ConstTupleWrap
+  , class TupleBase, class ConstTupleBase
+  >
+void test_ext_int_0()
+{
+    count = 0;
+    typedef A_int_0 T;
+    typedef A_wrap_0 Wrap;
+    typedef A_base_0 Base;
+
+    typedef int(T::*mem1_t)();
+    mem1_t mem1 = &T::mem1;
+
+    typedef int(T::*mem2_t)() const;
+    mem2_t mem2 = &T::mem2;
+
+    typedef int const T::*obj1_t;
+    obj1_t obj1 = &T::obj1;
+
+    // member function w/ref
+    {
+        T a;
+        Tuple t{a};
+        assert(1 == std::apply(mem1, t));
+        assert(count == 1);
+    }
+    count = 0;
+    // member function w/pointer
+    {
+        T a;
+        TuplePtr t{&a};
+        assert(1 == std::apply(mem1, t));
+        assert(count == 1);
+    }
+    count = 0;
+    // member function w/base
+    {
+        Base a;
+        TupleBase t{a};
+        assert(1 == std::apply(mem1, t));
+        assert(count == 1);
+    }
+    count = 0;
+    // member function w/wrap
+    {
+        Wrap a;
+        TupleWrap t{a};
+        assert(1 == std::apply(mem1, t));
+        assert(count == 1);
+    }
+    count = 0;
+    // const member function w/ref
+    {
+        T const a;
+        ConstTuple t{a};
+        assert(1 == std::apply(mem2, t));
+        assert(count == 1);
+    }
+    count = 0;
+    // const member function w/pointer
+    {
+        T const a;
+        ConstTuplePtr t{&a};
+        assert(1 == std::apply(mem2, t));
+        assert(count == 1);
+    }
+    count = 0;
+    // const member function w/base
+    {
+        Base const a;
+        ConstTupleBase t{a};
+        assert(1 == std::apply(mem2, t));
+        assert(count == 1);
+    }
+    count = 0;
+    // const member function w/wrapper
+    {
+        Wrap const a;
+        ConstTupleWrap t{a};
+        assert(1 == std::apply(mem2, t));
+        assert(1 == count);
+    }
+    // member object w/ref
+    {
+        T a{42};
+        Tuple t{a};
+        assert(42 == std::apply(obj1, t));
+    }
+    // member object w/pointer
+    {
+        T a{42};
+        TuplePtr t{&a};
+        assert(42 == std::apply(obj1, t));
+    }
+    // member object w/base
+    {
+        Base a{42};
+        TupleBase t{a};
+        assert(42 == std::apply(obj1, t));
+    }
+    // member object w/wrapper
+    {
+        Wrap a{42};
+        TupleWrap t{a};
+        assert(42 == std::apply(obj1, t));
+    }
+}
+
+
+template <
+    class Tuple, class ConstTuple
+  , class TuplePtr, class ConstTuplePtr
+  , class TupleWrap, class ConstTupleWrap
+  , class TupleBase, class ConstTupleBase
+  >
+void test_ext_int_1()
+{
+    count = 0;
+    typedef A_int_1 T;
+    typedef A_wrap_1 Wrap;
+    typedef A_base_1 Base;
+
+    typedef int(T::*mem1_t)(int);
+    mem1_t mem1 = &T::mem1;
+
+    typedef int(T::*mem2_t)(int) const;
+    mem2_t mem2 = &T::mem2;
+
+    // member function w/ref
+    {
+        T a;
+        Tuple t{a, 2};
+        assert(2 == std::apply(mem1, t));
+        assert(count == 2);
+    }
+    count = 0;
+    // member function w/pointer
+    {
+        T a;
+        TuplePtr t{&a, 3};
+        assert(3 == std::apply(mem1, t));
+        assert(count == 3);
+    }
+    count = 0;
+    // member function w/base
+    {
+        Base a;
+        TupleBase t{a, 4};
+        assert(4 == std::apply(mem1, t));
+        assert(count == 4);
+    }
+    count = 0;
+    // member function w/wrap
+    {
+        Wrap a;
+        TupleWrap t{a, 5};
+        assert(5 == std::apply(mem1, t));
+        assert(count == 5);
+    }
+    count = 0;
+    // const member function w/ref
+    {
+        T const a;
+        ConstTuple t{a, 6};
+        assert(6 == std::apply(mem2, t));
+        assert(count == 6);
+    }
+    count = 0;
+    // const member function w/pointer
+    {
+        T const a;
+        ConstTuplePtr t{&a, 7};
+        assert(7 == std::apply(mem2, t));
+        assert(count == 7);
+    }
+    count = 0;
+    // const member function w/base
+    {
+        Base const a;
+        ConstTupleBase t{a, 8};
+        assert(8 == std::apply(mem2, t));
+        assert(count == 8);
+    }
+    count = 0;
+    // const member function w/wrapper
+    {
+        Wrap const a;
+        ConstTupleWrap t{a, 9};
+        assert(9 == std::apply(mem2, t));
+        assert(9 == count);
+    }
+}
+
+
+template <
+    class Tuple, class ConstTuple
+  , class TuplePtr, class ConstTuplePtr
+  , class TupleWrap, class ConstTupleWrap
+  , class TupleBase, class ConstTupleBase
+  >
+void test_ext_int_2()
+{
+    count = 0;
+    typedef A_int_2 T;
+    typedef A_wrap_2 Wrap;
+    typedef A_base_2 Base;
+
+    typedef int(T::*mem1_t)(int, int);
+    mem1_t mem1 = &T::mem1;
+
+    typedef int(T::*mem2_t)(int, int) const;
+    mem2_t mem2 = &T::mem2;
+
+    // member function w/ref
+    {
+        T a;
+        Tuple t{a, 1, 1};
+        assert(2 == std::apply(mem1, t));
+        assert(count == 2);
+    }
+    count = 0;
+    // member function w/pointer
+    {
+        T a;
+        TuplePtr t{&a, 1, 2};
+        assert(3 == std::apply(mem1, t));
+        assert(count == 3);
+    }
+    count = 0;
+    // member function w/base
+    {
+        Base a;
+        TupleBase t{a, 2, 2};
+        assert(4 == std::apply(mem1, t));
+        assert(count == 4);
+    }
+    count = 0;
+    // member function w/wrap
+    {
+        Wrap a;
+        TupleWrap t{a, 2, 3};
+        assert(5 == std::apply(mem1, t));
+        assert(count == 5);
+    }
+    count = 0;
+    // const member function w/ref
+    {
+        T const a;
+        ConstTuple t{a, 3, 3};
+        assert(6 == std::apply(mem2, t));
+        assert(count == 6);
+    }
+    count = 0;
+    // const member function w/pointer
+    {
+        T const a;
+        ConstTuplePtr t{&a, 3, 4};
+        assert(7 == std::apply(mem2, t));
+        assert(count == 7);
+    }
+    count = 0;
+    // const member function w/base
+    {
+        Base const a;
+        ConstTupleBase t{a, 4, 4};
+        assert(8 == std::apply(mem2, t));
+        assert(count == 8);
+    }
+    count = 0;
+    // const member function w/wrapper
+    {
+        Wrap const a;
+        ConstTupleWrap t{a, 4, 5};
+        assert(9 == std::apply(mem2, t));
+        assert(9 == count);
+    }
+}
+
+int main()
+{
+    {
+        test_ext_int_0<
+            std::tuple<A_int_0 &>, std::tuple<A_int_0 const &>
+          , std::tuple<A_int_0 *>, std::tuple<A_int_0 const *>
+          , std::tuple<A_wrap_0 &>, std::tuple<A_wrap_0 const &>
+          , std::tuple<A_base_0 &>, std::tuple<A_base_0 const &>
+          >();
+        test_ext_int_0<
+            std::tuple<A_int_0>, std::tuple<A_int_0 const>
+          , std::tuple<A_int_0 *>, std::tuple<A_int_0 const *>
+          , std::tuple<A_wrap_0>, std::tuple<A_wrap_0 const>
+          , std::tuple<A_base_0>, std::tuple<A_base_0 const>
+          >();
+        test_ext_int_0<
+            std::array<A_int_0, 1>, std::array<A_int_0 const, 1>
+          , std::array<A_int_0*, 1>, std::array<A_int_0 const*, 1>
+          , std::array<A_wrap_0, 1>, std::array<A_wrap_0 const, 1>
+          , std::array<A_base_0, 1>, std::array<A_base_0 const, 1>
+          >();
+    }
+    {
+        test_ext_int_1<
+            std::tuple<A_int_1 &, int>, std::tuple<A_int_1 const &, int>
+          , std::tuple<A_int_1 *, int>, std::tuple<A_int_1 const *, int>
+          , std::tuple<A_wrap_1 &, int>, std::tuple<A_wrap_1 const &, int>
+          , std::tuple<A_base_1 &, int>, std::tuple<A_base_1 const &, int>
+          >();
+        test_ext_int_1<
+            std::tuple<A_int_1, int>, std::tuple<A_int_1 const, int>
+          , std::tuple<A_int_1 *, int>, std::tuple<A_int_1 const *, int>
+          , std::tuple<A_wrap_1, int>, std::tuple<A_wrap_1 const, int>
+          , std::tuple<A_base_1, int>, std::tuple<A_base_1 const, int>
+          >();
+        test_ext_int_1<
+            std::pair<A_int_1 &, int>, std::pair<A_int_1 const &, int>
+          , std::pair<A_int_1 *, int>, std::pair<A_int_1 const *, int>
+          , std::pair<A_wrap_1 &, int>, std::pair<A_wrap_1 const &, int>
+          , std::pair<A_base_1 &, int>, std::pair<A_base_1 const &, int>
+          >();
+        test_ext_int_1<
+            std::pair<A_int_1, int>, std::pair<A_int_1 const, int>
+          , std::pair<A_int_1 *, int>, std::pair<A_int_1 const *, int>
+          , std::pair<A_wrap_1, int>, std::pair<A_wrap_1 const, int>
+          , std::pair<A_base_1, int>, std::pair<A_base_1 const, int>
+          >();
+    }
+    {
+        test_ext_int_2<
+            std::tuple<A_int_2 &, int, int>, std::tuple<A_int_2 const &, int, int>
+          , std::tuple<A_int_2 *, int, int>, std::tuple<A_int_2 const *, int, int>
+          , std::tuple<A_wrap_2 &, int, int>, std::tuple<A_wrap_2 const &, int, int>
+          , std::tuple<A_base_2 &, int, int>, std::tuple<A_base_2 const &, int, int>
+          >();
+        test_ext_int_2<
+            std::tuple<A_int_2, int, int>, std::tuple<A_int_2 const, int, int>
+          , std::tuple<A_int_2 *, int, int>, std::tuple<A_int_2 const *, int, int>
+          , std::tuple<A_wrap_2, int, int>, std::tuple<A_wrap_2 const, int, int>
+          , std::tuple<A_base_2, int, int>, std::tuple<A_base_2 const, int, int>
+          >();
+    }
+}
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply_large_arity.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply_large_arity.pass.cpp
new file mode 100644
index 000000000000..33c3ef5956e4
--- /dev/null
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply_large_arity.pass.cpp
@@ -0,0 +1,144 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11, c++14
+
+// <tuple>
+
+// template <class F, class T> constexpr decltype(auto) apply(F &&, T &&)
+
+// Stress testing large arities with tuple and array.
+
+#include <tuple>
+#include <array>
+#include <utility>
+#include <cassert>
+
+////////////////////////////////////////////////////////////////////////////////
+template <class T, std::size_t Dummy = 0>
+struct always_imp
+{
+    typedef T type;
+};
+
+template <class T, std::size_t Dummy = 0>
+using always_t = typename always_imp<T, Dummy>::type;
+
+////////////////////////////////////////////////////////////////////////////////
+template <class Tuple, class Idx>
+struct make_function;
+
+template <class Tp, std::size_t ...Idx>
+struct make_function<Tp, std::integer_sequence<std::size_t, Idx...>>
+{
+    using type = bool (*)(always_t<Tp, Idx>...);
+};
+
+template <class Tp, std::size_t Size>
+using make_function_t = typename make_function<Tp, std::make_index_sequence<Size>>::type;
+
+////////////////////////////////////////////////////////////////////////////////
+template <class Tp, class Idx>
+struct make_tuple_imp;
+
+////////////////////////////////////////////////////////////////////////////////
+template <class Tp, std::size_t ...Idx>
+struct make_tuple_imp<Tp, std::integer_sequence<std::size_t, Idx...>>
+{
+    using type = std::tuple<always_t<Tp, Idx>...>;
+};
+
+template <class Tp, std::size_t Size>
+using make_tuple_t = typename make_tuple_imp<Tp, std::make_index_sequence<Size>>::type;
+
+template <class ...Types>
+bool test_apply_fn(Types...) { return true; }
+
+
+template <std::size_t Size>
+void test_all()
+{
+
+    using A = std::array<int, Size>;
+    using ConstA = std::array<int const, Size>;
+
+    using Tuple = make_tuple_t<int, Size>;
+    using CTuple = make_tuple_t<const int, Size>;
+
+    using ValFn  = make_function_t<int, Size>;
+    ValFn val_fn = &test_apply_fn;
+
+    using RefFn  = make_function_t<int &, Size>;
+    RefFn ref_fn = &test_apply_fn;
+
+    using CRefFn = make_function_t<int const &, Size>;
+    CRefFn cref_fn = &test_apply_fn;
+
+    using RRefFn = make_function_t<int &&, Size>;
+    RRefFn rref_fn = &test_apply_fn;
+
+    {
+        A a{};
+        assert(std::apply(val_fn, a));
+        assert(std::apply(ref_fn, a));
+        assert(std::apply(cref_fn, a));
+        assert(std::apply(rref_fn, std::move(a)));
+    }
+    {
+        ConstA a{};
+        assert(std::apply(val_fn, a));
+        assert(std::apply(cref_fn, a));
+    }
+    {
+        Tuple a{};
+        assert(std::apply(val_fn, a));
+        assert(std::apply(ref_fn, a));
+        assert(std::apply(cref_fn, a));
+        assert(std::apply(rref_fn, std::move(a)));
+    }
+    {
+        CTuple a{};
+        assert(std::apply(val_fn, a));
+        assert(std::apply(cref_fn, a));
+    }
+
+}
+
+
+template <std::size_t Size>
+void test_one()
+{
+    using A = std::array<int, Size>;
+    using Tuple = make_tuple_t<int, Size>;
+
+    using ValFn  = make_function_t<int, Size>;
+    ValFn val_fn = &test_apply_fn;
+
+    {
+        A a{};
+        assert(std::apply(val_fn, a));
+    }
+    {
+        Tuple a{};
+        assert(std::apply(val_fn, a));
+    }
+}
+
+int main()
+{
+    // Instantiate with 1-5 arguments.
+    test_all<1>();
+    test_all<2>();
+    test_all<3>();
+    test_all<4>();
+    test_all<5>();
+
+    // Stress test with 256
+    test_one<256>();
+}
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.apply/make_from_tuple.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.apply/make_from_tuple.pass.cpp
new file mode 100644
index 000000000000..143ae195e6f4
--- /dev/null
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.apply/make_from_tuple.pass.cpp
@@ -0,0 +1,214 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11, c++14
+
+// <tuple>
+
+// template <class T, class Tuple> constexpr T make_from_tuple(Tuple&&);
+
+#include <tuple>
+#include <array>
+#include <utility>
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+#include "type_id.h"
+
+// std::array is explicitly allowed to be initialized with A a = { init-list };.
+// Disable the missing braces warning for this reason.
+#include "disable_missing_braces_warning.h"
+
+template <class Tuple>
+struct ConstexprConstructibleFromTuple {
+  template <class ...Args>
+  explicit constexpr ConstexprConstructibleFromTuple(Args&&... xargs)
+      : args{std::forward<Args>(xargs)...} {}
+  Tuple args;
+};
+
+template <class TupleLike>
+struct ConstructibleFromTuple;
+
+template <template <class ...> class Tuple, class ...Types>
+struct ConstructibleFromTuple<Tuple<Types...>> {
+  template <class ...Args>
+  explicit ConstructibleFromTuple(Args&&... xargs)
+      : args(xargs...),
+        arg_types(&makeArgumentID<Args&&...>())
+  {}
+  Tuple<std::decay_t<Types>...> args;
+  TypeID const* arg_types;
+};
+
+template <class Tp, size_t N>
+struct ConstructibleFromTuple<std::array<Tp, N>> {
+template <class ...Args>
+  explicit ConstructibleFromTuple(Args&&... xargs)
+      : args{xargs...},
+        arg_types(&makeArgumentID<Args&&...>())
+  {}
+  std::array<Tp, N> args;
+  TypeID const* arg_types;
+};
+
+template <class Tuple>
+constexpr bool do_constexpr_test(Tuple&& tup) {
+    using RawTuple = std::decay_t<Tuple>;
+    using Tp = ConstexprConstructibleFromTuple<RawTuple>;
+    return std::make_from_tuple<Tp>(std::forward<Tuple>(tup)).args == tup;
+}
+
+// Needed by do_forwarding_test() since it compare pairs of different types.
+template <class T1, class T2, class U1, class U2>
+inline bool operator==(const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs) {
+    return lhs.first == rhs.first && lhs.second == rhs.second;
+}
+
+template <class ...ExpectTypes, class Tuple>
+bool do_forwarding_test(Tuple&& tup) {
+    using RawTuple = std::decay_t<Tuple>;
+    using Tp = ConstructibleFromTuple<RawTuple>;
+    const Tp value = std::make_from_tuple<Tp>(std::forward<Tuple>(tup));
+    return value.args == tup
+        && value.arg_types == &makeArgumentID<ExpectTypes...>();
+}
+
+void test_constexpr_construction() {
+    {
+        constexpr std::tuple<> tup;
+        static_assert(do_constexpr_test(tup), "");
+    }
+    {
+        constexpr std::tuple<int> tup(42);
+        static_assert(do_constexpr_test(tup), "");
+    }
+    {
+        constexpr std::tuple<int, long, void*> tup(42, 101, nullptr);
+        static_assert(do_constexpr_test(tup), "");
+    }
+    {
+        constexpr std::pair<int, const char*> p(42, "hello world");
+        static_assert(do_constexpr_test(p), "");
+    }
+    {
+        using Tuple = std::array<int, 3>;
+        using ValueTp = ConstexprConstructibleFromTuple<Tuple>;
+        constexpr Tuple arr = {42, 101, -1};
+        constexpr ValueTp value = std::make_from_tuple<ValueTp>(arr);
+        static_assert(value.args[0] == arr[0] && value.args[1] == arr[1]
+            && value.args[2] == arr[2], "");
+    }
+}
+
+void test_perfect_forwarding() {
+    {
+        using Tup = std::tuple<>;
+        Tup tup;
+        Tup const& ctup = tup;
+        assert(do_forwarding_test<>(tup));
+        assert(do_forwarding_test<>(ctup));
+    }
+    {
+        using Tup = std::tuple<int>;
+        Tup tup(42);
+        Tup const& ctup = tup;
+        assert(do_forwarding_test<int&>(tup));
+        assert(do_forwarding_test<int const&>(ctup));
+        assert(do_forwarding_test<int&&>(std::move(tup)));
+        assert(do_forwarding_test<int const&&>(std::move(ctup)));
+    }
+    {
+        using Tup = std::tuple<int&, const char*, unsigned&&>;
+        int x = 42;
+        unsigned y = 101;
+        Tup tup(x, "hello world", std::move(y));
+        Tup const& ctup = tup;
+        assert((do_forwarding_test<int&, const char*&, unsigned&>(tup)));
+        assert((do_forwarding_test<int&, const char* const&, unsigned &>(ctup)));
+        assert((do_forwarding_test<int&, const char*&&, unsigned&&>(std::move(tup))));
+        assert((do_forwarding_test<int&, const char* const&&, unsigned &&>(std::move(ctup))));
+    }
+    // test with pair<T, U>
+    {
+        using Tup = std::pair<int&, const char*>;
+        int x = 42;
+        Tup tup(x, "hello world");
+        Tup const& ctup = tup;
+        assert((do_forwarding_test<int&, const char*&>(tup)));
+        assert((do_forwarding_test<int&, const char* const&>(ctup)));
+        assert((do_forwarding_test<int&, const char*&&>(std::move(tup))));
+        assert((do_forwarding_test<int&, const char* const&&>(std::move(ctup))));
+    }
+    // test with array<T, I>
+    {
+        using Tup = std::array<int, 3>;
+        Tup tup = {42, 101, -1};
+        Tup const& ctup = tup;
+        assert((do_forwarding_test<int&, int&, int&>(tup)));
+        assert((do_forwarding_test<int const&, int const&, int const&>(ctup)));
+        assert((do_forwarding_test<int&&, int&&, int&&>(std::move(tup))));
+        assert((do_forwarding_test<int const&&, int const&&, int const&&>(std::move(ctup))));
+    }
+}
+
+void test_noexcept() {
+    struct NothrowMoveable {
+      NothrowMoveable() = default;
+      NothrowMoveable(NothrowMoveable const&) {}
+      NothrowMoveable(NothrowMoveable&&) noexcept {}
+    };
+    struct TestType {
+      TestType(int, NothrowMoveable) noexcept {}
+      TestType(int, int, int) noexcept(false) {}
+      TestType(long, long, long) noexcept {}
+    };
+    {
+        using Tuple = std::tuple<int, NothrowMoveable>;
+        Tuple tup; ((void)tup);
+        Tuple const& ctup = tup; ((void)ctup);
+        ASSERT_NOT_NOEXCEPT(std::make_from_tuple<TestType>(ctup));
+        ASSERT_NOEXCEPT(std::make_from_tuple<TestType>(std::move(tup)));
+    }
+    {
+        using Tuple = std::pair<int, NothrowMoveable>;
+        Tuple tup; ((void)tup);
+        Tuple const& ctup = tup; ((void)ctup);
+        ASSERT_NOT_NOEXCEPT(std::make_from_tuple<TestType>(ctup));
+        ASSERT_NOEXCEPT(std::make_from_tuple<TestType>(std::move(tup)));
+    }
+    {
+        using Tuple = std::tuple<int, int, int>;
+        Tuple tup; ((void)tup);
+        ASSERT_NOT_NOEXCEPT(std::make_from_tuple<TestType>(tup));
+    }
+    {
+        using Tuple = std::tuple<long, long, long>;
+        Tuple tup; ((void)tup);
+        ASSERT_NOEXCEPT(std::make_from_tuple<TestType>(tup));
+    }
+    {
+        using Tuple = std::array<int, 3>;
+        Tuple tup; ((void)tup);
+        ASSERT_NOT_NOEXCEPT(std::make_from_tuple<TestType>(tup));
+    }
+    {
+        using Tuple = std::array<long, 3>;
+        Tuple tup; ((void)tup);
+        ASSERT_NOEXCEPT(std::make_from_tuple<TestType>(tup));
+    }
+}
+
+int main()
+{
+    test_constexpr_construction();
+    test_perfect_forwarding();
+    test_noexcept();
+}
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_copy.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_copy.pass.cpp
index 2dde6b5521f2..91892efaf139 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_copy.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_copy.pass.cpp
@@ -74,4 +74,16 @@ int main()
         assert(std::get<1>(t1) == int('a'));
         assert(std::get<2>(t1).id_ == 2);
     }
+    {
+        // Test that tuple evaluates correctly applies an lvalue reference
+        // before evaluating is_assignable (ie 'is_assignable<int&, int&>')
+        // instead of evaluating 'is_assignable<int&&, int&>' which is false.
+        int x = 42;
+        int y = 43;
+        std::tuple<int&&> t(std::move(x));
+        std::tuple<int&> t2(y);
+        t = t2;
+        assert(std::get<0>(t) == 43);
+        assert(&std::get<0>(t) == &x);
+    }
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_move.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_move.pass.cpp
index 11bfdd0c94a9..afd3e0fdb8e3 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_move.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_move.pass.cpp
@@ -37,6 +37,13 @@ struct D
     explicit D(int i) : B(i) {}
 };
 
+struct E {
+  E() = default;
+  E& operator=(int val) {
+      return *this;
+  }
+};
+
 int main()
 {
     {
@@ -88,4 +95,16 @@ int main()
         assert(std::get<1>(t1) == int('a'));
         assert(std::get<2>(t1)->id_ == 3);
     }
+    {
+        // Test that tuple evaluates correctly applies an lvalue reference
+        // before evaluating is_assignable (ie 'is_assignable<int&, int&&>')
+        // instead of evaluating 'is_assignable<int&&, int&&>' which is false.
+        int x = 42;
+        int y = 43;
+        std::tuple<int&&, E> t(std::move(x), E{});
+        std::tuple<int&&, int> t2(std::move(y), 44);
+        t = std::move(t2);
+        assert(std::get<0>(t) == 43);
+        assert(&std::get<0>(t) == &x);
+    }
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR22806_constrain_tuple_like_ctor.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR22806_constrain_tuple_like_ctor.pass.cpp
new file mode 100644
index 000000000000..4ddfb463385c
--- /dev/null
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR22806_constrain_tuple_like_ctor.pass.cpp
@@ -0,0 +1,178 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <tuple>
+
+// template <class... Types> class tuple;
+
+// template <class TupleLike>
+//   tuple(TupleLike&&);
+// template <class Alloc, class TupleLike>
+//   tuple(std::allocator_arg_t, Alloc const&, TupleLike&&);
+
+// Check that the tuple-like ctors are properly disabled when the UTypes...
+// constructor should be selected. See PR22806.
+
+#include <tuple>
+#include <memory>
+#include <cassert>
+
+template <class Tp>
+using uncvref_t = typename std::remove_cv<typename std::remove_reference<Tp>::type>::type;
+
+template <class Tuple, class = uncvref_t<Tuple>>
+struct IsTuple : std::false_type {};
+
+template <class Tuple, class ...Args>
+struct IsTuple<Tuple, std::tuple<Args...>> : std::true_type {};
+
+struct ConstructibleFromTupleAndInt {
+  enum State { FromTuple, FromInt, Copied, Moved };
+  State state;
+
+  ConstructibleFromTupleAndInt(ConstructibleFromTupleAndInt const&) : state(Copied) {}
+  ConstructibleFromTupleAndInt(ConstructibleFromTupleAndInt &&) : state(Moved) {}
+
+  template <class Tuple, class = typename std::enable_if<IsTuple<Tuple>::value>::type>
+  explicit ConstructibleFromTupleAndInt(Tuple&&) : state(FromTuple) {}
+
+  explicit ConstructibleFromTupleAndInt(int) : state(FromInt) {}
+};
+
+struct ConvertibleFromTupleAndInt {
+  enum State { FromTuple, FromInt, Copied, Moved };
+  State state;
+
+  ConvertibleFromTupleAndInt(ConvertibleFromTupleAndInt const&) : state(Copied) {}
+  ConvertibleFromTupleAndInt(ConvertibleFromTupleAndInt &&) : state(Moved) {}
+
+  template <class Tuple, class = typename std::enable_if<IsTuple<Tuple>::value>::type>
+  ConvertibleFromTupleAndInt(Tuple&&) : state(FromTuple) {}
+
+  ConvertibleFromTupleAndInt(int) : state(FromInt) {}
+};
+
+struct ConstructibleFromInt {
+  enum State { FromInt, Copied, Moved };
+  State state;
+
+  ConstructibleFromInt(ConstructibleFromInt const&) : state(Copied) {}
+  ConstructibleFromInt(ConstructibleFromInt &&) : state(Moved) {}
+
+  explicit ConstructibleFromInt(int) : state(FromInt) {}
+};
+
+struct ConvertibleFromInt {
+  enum State { FromInt, Copied, Moved };
+  State state;
+
+  ConvertibleFromInt(ConvertibleFromInt const&) : state(Copied) {}
+  ConvertibleFromInt(ConvertibleFromInt &&) : state(Moved) {}
+  ConvertibleFromInt(int) : state(FromInt) {}
+};
+
+int main()
+{
+    // Test for the creation of dangling references when a tuple is used to
+    // store a reference to another tuple as its only element.
+    // Ex std::tuple<std::tuple<int>&&>.
+    // In this case the constructors 1) 'tuple(UTypes&&...)'
+    // and 2) 'tuple(TupleLike&&)' need to be manually disambiguated because
+    // when both #1 and #2 participate in partial ordering #2 will always
+    // be chosen over #1.
+    // See PR22806  and LWG issue #2549 for more information.
+    // (https://llvm.org/bugs/show_bug.cgi?id=22806)
+    using T = std::tuple<int>;
+    std::allocator<int> A;
+    { // rvalue reference
+        T t1(42);
+        std::tuple< T&& > t2(std::move(t1));
+        assert(&std::get<0>(t2) == &t1);
+    }
+    { // const lvalue reference
+        T t1(42);
+
+        std::tuple< T const & > t2(t1);
+        assert(&std::get<0>(t2) == &t1);
+
+        std::tuple< T const & > t3(static_cast<T const&>(t1));
+        assert(&std::get<0>(t3) == &t1);
+    }
+    { // lvalue reference
+        T t1(42);
+
+        std::tuple< T & > t2(t1);
+        assert(&std::get<0>(t2) == &t1);
+    }
+    { // const rvalue reference
+        T t1(42);
+
+        std::tuple< T const && > t2(std::move(t1));
+        assert(&std::get<0>(t2) == &t1);
+    }
+    { // rvalue reference via uses-allocator
+        T t1(42);
+        std::tuple< T&& > t2(std::allocator_arg, A, std::move(t1));
+        assert(&std::get<0>(t2) == &t1);
+    }
+    { // const lvalue reference via uses-allocator
+        T t1(42);
+
+        std::tuple< T const & > t2(std::allocator_arg, A, t1);
+        assert(&std::get<0>(t2) == &t1);
+
+        std::tuple< T const & > t3(std::allocator_arg, A, static_cast<T const&>(t1));
+        assert(&std::get<0>(t3) == &t1);
+    }
+    { // lvalue reference via uses-allocator
+        T t1(42);
+
+        std::tuple< T & > t2(std::allocator_arg, A, t1);
+        assert(&std::get<0>(t2) == &t1);
+    }
+    { // const rvalue reference via uses-allocator
+        T const t1(42);
+        std::tuple< T const && > t2(std::allocator_arg, A, std::move(t1));
+        assert(&std::get<0>(t2) == &t1);
+    }
+    // Test constructing a 1-tuple of the form tuple<UDT> from another 1-tuple
+    // 'tuple<T>' where UDT *can* be constructed from 'tuple<T>' In this case
+    // the 'tuple(UTypes...)' ctor should be choosen and 'UDT' constructed frow
+    // 'tuple<T>'.
+    {
+        using VT = ConstructibleFromTupleAndInt;
+        std::tuple<int> t1(42);
+        std::tuple<VT> t2(t1);
+        assert(std::get<0>(t2).state == VT::FromTuple);
+    }
+    {
+        using VT = ConvertibleFromTupleAndInt;
+        std::tuple<int> t1(42);
+        std::tuple<VT> t2 = {t1};
+        assert(std::get<0>(t2).state == VT::FromTuple);
+    }
+    // Test constructing a 1-tuple of the form tuple<UDT> from another 1-tuple
+    // 'tuple<T>' where UDT cannot be constructed from 'tuple<T>' but can
+    // be constructed from 'T'. In this case the tuple-like ctor should be
+    // chosen and 'UDT' constructed from 'T'
+    {
+        using VT = ConstructibleFromInt;
+        std::tuple<int> t1(42);
+        std::tuple<VT> t2(t1);
+        assert(std::get<0>(t2).state == VT::FromInt);
+    }
+    {
+        using VT = ConvertibleFromInt;
+        std::tuple<int> t1(42);
+        std::tuple<VT> t2 = {t1};
+        assert(std::get<0>(t2).state == VT::FromInt);
+    }
+}
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR23256_constrain_UTypes_ctor.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR23256_constrain_UTypes_ctor.pass.cpp
new file mode 100644
index 000000000000..ed3cafadbf08
--- /dev/null
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR23256_constrain_UTypes_ctor.pass.cpp
@@ -0,0 +1,96 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <tuple>
+
+// template <class... Types> class tuple;
+
+// template <class ...UTypes>
+//    EXPLICIT(...) tuple(UTypes&&...)
+
+// Check that the UTypes... ctor is properly disabled before evaluating any
+// SFINAE when the tuple-like copy/move ctor should *clearly* be selected
+// instead. This happens 'sizeof...(UTypes) == 1' and the first element of
+// 'UTypes...' is an instance of the tuple itself. See PR23256.
+
+#include <tuple>
+#include <memory>
+#include <type_traits>
+
+
+struct UnconstrainedCtor {
+  int value_;
+
+  UnconstrainedCtor() : value_(0) {}
+
+  // Blows up when instantiated for any type other than int. Because the ctor
+  // is constexpr it is instantiated by 'is_constructible' and 'is_convertible'
+  // for Clang based compilers. GCC does not instantiate the ctor body
+  // but it does instantiate the noexcept specifier and it will blow up there.
+  template <typename T>
+  constexpr UnconstrainedCtor(T value) noexcept(noexcept(value_ = value))
+      : value_(static_cast<int>(value))
+  {
+      static_assert(std::is_same<int, T>::value, "");
+  }
+};
+
+struct ExplicitUnconstrainedCtor {
+  int value_;
+
+  ExplicitUnconstrainedCtor() : value_(0) {}
+
+  template <typename T>
+  constexpr explicit ExplicitUnconstrainedCtor(T value)
+    noexcept(noexcept(value_ = value))
+      : value_(static_cast<int>(value))
+  {
+      static_assert(std::is_same<int, T>::value, "");
+  }
+
+};
+
+int main() {
+    typedef UnconstrainedCtor A;
+    typedef ExplicitUnconstrainedCtor ExplicitA;
+    {
+        static_assert(std::is_copy_constructible<std::tuple<A>>::value, "");
+        static_assert(std::is_move_constructible<std::tuple<A>>::value, "");
+        static_assert(std::is_copy_constructible<std::tuple<ExplicitA>>::value, "");
+        static_assert(std::is_move_constructible<std::tuple<ExplicitA>>::value, "");
+    }
+    {
+        static_assert(std::is_constructible<
+            std::tuple<A>,
+            std::allocator_arg_t, std::allocator<void>,
+            std::tuple<A> const&
+        >::value, "");
+        static_assert(std::is_constructible<
+            std::tuple<A>,
+            std::allocator_arg_t, std::allocator<void>,
+            std::tuple<A> &&
+        >::value, "");
+        static_assert(std::is_constructible<
+            std::tuple<ExplicitA>,
+            std::allocator_arg_t, std::allocator<void>,
+            std::tuple<ExplicitA> const&
+        >::value, "");
+        static_assert(std::is_constructible<
+            std::tuple<ExplicitA>,
+            std::allocator_arg_t, std::allocator<void>,
+            std::tuple<ExplicitA> &&
+        >::value, "");
+    }
+    {
+        std::tuple<A&&> t(std::forward_as_tuple(A{}));
+        std::tuple<ExplicitA&&> t2(std::forward_as_tuple(ExplicitA{}));
+    }
+}
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR27684_contains_ref_to_incomplete_type.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR27684_contains_ref_to_incomplete_type.pass.cpp
new file mode 100644
index 000000000000..c8b722f836c1
--- /dev/null
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR27684_contains_ref_to_incomplete_type.pass.cpp
@@ -0,0 +1,51 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <tuple>
+
+// template <class... Types> class tuple;
+
+// template <class Alloc> tuple(allocator_arg_t, Alloc const&)
+
+// Libc++ has to deduce the 'allocator_arg_t' parameter for this constructor
+// as 'AllocArgT'. Previously libc++ has tried to support tags derived from
+// 'allocator_arg_t' by using 'is_base_of<AllocArgT, allocator_arg_t>'.
+// However this breaks whenever a 2-tuple contains a reference to an incomplete
+// type as its first parameter. See PR27684.
+
+#include <tuple>
+#include <cassert>
+
+struct IncompleteType;
+extern IncompleteType inc1;
+extern IncompleteType inc2;
+IncompleteType const& cinc1 = inc1;
+IncompleteType const& cinc2 = inc2;
+
+int main() {
+    using IT = IncompleteType;
+    { // try calling tuple(Tp const&...)
+        using Tup = std::tuple<const IT&, const IT&>;
+        Tup t(cinc1, cinc2);
+        assert(&std::get<0>(t) == &inc1);
+        assert(&std::get<1>(t) == &inc2);
+    }
+    { // try calling tuple(Up&&...)
+        using Tup = std::tuple<const IT&, const IT&>;
+        Tup t(inc1, inc2);
+        assert(&std::get<0>(t) == &inc1);
+        assert(&std::get<1>(t) == &inc2);
+    }
+}
+
+struct IncompleteType {};
+IncompleteType inc1;
+IncompleteType inc2;
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/UTypes.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/UTypes.pass.cpp
index 817cc8f10990..6ab303c735be 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/UTypes.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/UTypes.pass.cpp
@@ -82,6 +82,8 @@ void test_default_constructible_extension_sfinae()
             MoveOnly, Tuple, MoveOnly, MoveOnly
         >::value, "");
     }
+    // testing extensions
+#ifdef _LIBCPP_VERSION
     {
         typedef std::tuple<MoveOnly, int> Tuple;
         typedef std::tuple<MoveOnly, Tuple, MoveOnly, MoveOnly> NestedTuple;
@@ -96,6 +98,7 @@ void test_default_constructible_extension_sfinae()
             MoveOnly, Tuple, MoveOnly, MoveOnly
         >::value, "");
     }
+#endif
 }
 
 int main()
@@ -118,6 +121,7 @@ int main()
         assert(std::get<2>(t) == 2);
     }
     // extensions
+#ifdef _LIBCPP_VERSION
     {
         std::tuple<MoveOnly, MoveOnly, MoveOnly> t(MoveOnly(0),
                                                    MoveOnly(1));
@@ -131,7 +135,8 @@ int main()
         assert(std::get<1>(t) == MoveOnly());
         assert(std::get<2>(t) == MoveOnly());
     }
-#if _LIBCPP_STD_VER > 11
+#endif
+#if TEST_STD_VER > 11
     {
         constexpr std::tuple<Empty> t0{Empty()};
     }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc.pass.cpp
index 39776822cbda..4da5fc7f8397 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <tuple>
 
 // template <class... Types> class tuple;
@@ -14,7 +16,9 @@
 // template <class Alloc>
 //   tuple(allocator_arg_t, const Alloc& a);
 
-// UNSUPPORTED: c++98, c++03
+// NOTE: this constructor does not currently support tags derived from
+// allocator_arg_t because libc++ has to deduce the parameter as a template
+// argument. See PR27684 (https://llvm.org/bugs/show_bug.cgi?id=27684)
 
 #include <tuple>
 #include <cassert>
@@ -24,6 +28,18 @@
 #include "../alloc_first.h"
 #include "../alloc_last.h"
 
+template <class T = void>
+struct NonDefaultConstructible {
+  constexpr NonDefaultConstructible() {
+      static_assert(!std::is_same<T, T>::value, "Default Ctor instantiated");
+  }
+
+  explicit constexpr NonDefaultConstructible(int) {}
+};
+
+
+struct DerivedFromAllocArgT : std::allocator_arg_t {};
+
 int main()
 {
     {
@@ -78,4 +94,14 @@ int main()
         assert(!alloc_last::allocator_constructed);
         assert(std::get<2>(t) == alloc_last());
     }
+    {
+        // Test that the uses-allocator default constructor does not evaluate
+        // it's SFINAE when it otherwise shouldn't be selected. Do this by
+        // using 'NonDefaultConstructible' which will cause a compile error
+        // if std::is_default_constructible is evaluated on it.
+        using T = NonDefaultConstructible<>;
+        T v(42);
+        std::tuple<T, T> t(v, v);
+        std::tuple<T, T> t2(42, 42);
+    }
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_UTypes.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_UTypes.pass.cpp
index 3929965cd273..e174e9b321b8 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_UTypes.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_UTypes.pass.cpp
@@ -24,16 +24,29 @@
 #include "../alloc_first.h"
 #include "../alloc_last.h"
 
-struct NoDefault { NoDefault() = delete; };
+template <class T = void>
+struct DefaultCtorBlowsUp {
+  constexpr DefaultCtorBlowsUp() {
+      static_assert(!std::is_same<T, T>::value, "Default Ctor instantiated");
+  }
 
-// Make sure the _Up... constructor SFINAEs out when the types that
-// are not explicitly initialized are not all default constructible.
-// Otherwise, std::is_constructible would return true but instantiating
-// the constructor would fail.
-void test_default_constructible_extension_sfinae()
+  explicit constexpr DefaultCtorBlowsUp(int x) : value(x) {}
+
+  int value;
+};
+
+
+struct DerivedFromAllocArgT : std::allocator_arg_t {};
+
+
+// Make sure the _Up... constructor SFINAEs out when the number of initializers
+// is less that the number of elements in the tuple. Previously libc++ would
+// offer these constructers as an extension but they broke conforming code.
+void test_uses_allocator_sfinae_evaluation()
 {
+     using BadDefault = DefaultCtorBlowsUp<>;
     {
-        typedef std::tuple<MoveOnly, NoDefault> Tuple;
+        typedef std::tuple<MoveOnly, MoveOnly, BadDefault> Tuple;
 
         static_assert(!std::is_constructible<
             Tuple,
@@ -42,11 +55,11 @@ void test_default_constructible_extension_sfinae()
 
         static_assert(std::is_constructible<
             Tuple,
-            std::allocator_arg_t, A1<int>, MoveOnly, NoDefault
+            std::allocator_arg_t, A1<int>, MoveOnly, MoveOnly, BadDefault
         >::value, "");
     }
     {
-        typedef std::tuple<MoveOnly, MoveOnly, NoDefault> Tuple;
+        typedef std::tuple<MoveOnly, MoveOnly, BadDefault, BadDefault> Tuple;
 
         static_assert(!std::is_constructible<
             Tuple,
@@ -55,53 +68,44 @@ void test_default_constructible_extension_sfinae()
 
         static_assert(std::is_constructible<
             Tuple,
-            std::allocator_arg_t, A1<int>, MoveOnly, MoveOnly, NoDefault
-        >::value, "");
-    }
-    {
-        // Same idea as above but with a nested tuple
-        typedef std::tuple<MoveOnly, NoDefault> Tuple;
-        typedef std::tuple<MoveOnly, Tuple, MoveOnly, MoveOnly> NestedTuple;
-
-        static_assert(!std::is_constructible<
-            NestedTuple,
-            std::allocator_arg_t, A1<int>, MoveOnly, MoveOnly, MoveOnly, MoveOnly
-        >::value, "");
-
-        static_assert(std::is_constructible<
-            NestedTuple,
-            std::allocator_arg_t, A1<int>, MoveOnly, Tuple, MoveOnly, MoveOnly
-        >::value, "");
-    }
-    {
-        typedef std::tuple<MoveOnly, int> Tuple;
-        typedef std::tuple<MoveOnly, Tuple, MoveOnly, MoveOnly> NestedTuple;
-
-        static_assert(std::is_constructible<
-            NestedTuple,
-            std::allocator_arg_t, A1<int>, MoveOnly, MoveOnly, MoveOnly, MoveOnly
-        >::value, "");
-
-        static_assert(std::is_constructible<
-            NestedTuple,
-            std::allocator_arg_t, A1<int>, MoveOnly, Tuple, MoveOnly, MoveOnly
+            std::allocator_arg_t, A1<int>, MoveOnly, MoveOnly, BadDefault, BadDefault
         >::value, "");
     }
 }
 
+struct Explicit {
+  int value;
+  explicit Explicit(int x) : value(x) {}
+};
+
 int main()
 {
     {
+        std::tuple<Explicit> t{std::allocator_arg, std::allocator<void>{}, 42};
+        assert(std::get<0>(t).value == 42);
+    }
+    {
         std::tuple<MoveOnly> t(std::allocator_arg, A1<int>(), MoveOnly(0));
         assert(std::get<0>(t) == 0);
     }
     {
+        using T = DefaultCtorBlowsUp<>;
+        std::tuple<T> t(std::allocator_arg, A1<int>(), T(42));
+        assert(std::get<0>(t).value == 42);
+    }
+    {
         std::tuple<MoveOnly, MoveOnly> t(std::allocator_arg, A1<int>(),
                                          MoveOnly(0), MoveOnly(1));
         assert(std::get<0>(t) == 0);
         assert(std::get<1>(t) == 1);
     }
     {
+        using T = DefaultCtorBlowsUp<>;
+        std::tuple<T, T> t(std::allocator_arg, A1<int>(), T(42), T(43));
+        assert(std::get<0>(t).value == 42);
+        assert(std::get<1>(t).value == 43);
+    }
+    {
         std::tuple<MoveOnly, MoveOnly, MoveOnly> t(std::allocator_arg, A1<int>(),
                                                    MoveOnly(0),
                                                    1, 2);
@@ -110,6 +114,13 @@ int main()
         assert(std::get<2>(t) == 2);
     }
     {
+        using T = DefaultCtorBlowsUp<>;
+        std::tuple<T, T, T> t(std::allocator_arg, A1<int>(), T(1), T(2), T(3));
+        assert(std::get<0>(t).value == 1);
+        assert(std::get<1>(t).value == 2);
+        assert(std::get<2>(t).value == 3);
+    }
+    {
         alloc_first::allocator_constructed = false;
         alloc_last::allocator_constructed = false;
         std::tuple<int, alloc_first, alloc_last> t(std::allocator_arg,
@@ -120,22 +131,22 @@ int main()
         assert(alloc_last::allocator_constructed);
         assert(std::get<2>(t) == alloc_last(3));
     }
-    // extensions
-    {
-        std::tuple<MoveOnly, MoveOnly, MoveOnly> t(std::allocator_arg, A1<int>(),
-                                                   0, 1);
-        assert(std::get<0>(t) == 0);
-        assert(std::get<1>(t) == 1);
-        assert(std::get<2>(t) == MoveOnly());
-    }
     {
-        std::tuple<MoveOnly, MoveOnly, MoveOnly> t(std::allocator_arg, A1<int>(),
-                                                   0);
-        assert(std::get<0>(t) == 0);
-        assert(std::get<1>(t) == MoveOnly());
-        assert(std::get<2>(t) == MoveOnly());
+        // Check that uses-allocator construction is still selected when
+        // given a tag type that derives from allocator_arg_t.
+        DerivedFromAllocArgT tag;
+        alloc_first::allocator_constructed = false;
+        alloc_last::allocator_constructed = false;
+        std::tuple<int, alloc_first, alloc_last> t(tag,
+                                                   A1<int>(5), 1, 2, 3);
+        assert(std::get<0>(t) == 1);
+        assert(alloc_first::allocator_constructed);
+        assert(std::get<1>(t) == alloc_first(2));
+        assert(alloc_last::allocator_constructed);
+        assert(std::get<2>(t) == alloc_last(3));
     }
-    // Check that SFINAE is properly applied with the default reduced arity
-    // constructor extensions.
-    test_default_constructible_extension_sfinae();
+    // Stress test the SFINAE on the uses-allocator constructors and
+    // ensure that the "reduced-arity-initialization" extension is not offered
+    // for these constructors.
+    test_uses_allocator_sfinae_evaluation();
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.fail.cpp
new file mode 100644
index 000000000000..b28ad6dab5ab
--- /dev/null
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.fail.cpp
@@ -0,0 +1,43 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... Types> class tuple;
+
+// template <class Alloc>
+//   EXPLICIT tuple(allocator_arg_t, const Alloc& a, const Types&...);
+
+// UNSUPPORTED: c++98, c++03
+
+#include <tuple>
+#include <memory>
+#include <cassert>
+
+struct ExplicitCopy {
+  explicit ExplicitCopy(ExplicitCopy const&) {}
+  explicit ExplicitCopy(int) {}
+};
+
+std::tuple<ExplicitCopy> const_explicit_copy_test() {
+    const ExplicitCopy e(42);
+    return {std::allocator_arg, std::allocator<void>{}, e};
+    // expected-error@-1 {{chosen constructor is explicit in copy-initialization}}
+}
+
+std::tuple<ExplicitCopy> non_const_explicity_copy_test() {
+    ExplicitCopy e(42);
+    return {std::allocator_arg, std::allocator<void>{}, e};
+    // expected-error@-1 {{chosen constructor is explicit in copy-initialization}}
+}
+int main()
+{
+    const_explicit_copy_test();
+    non_const_explicity_copy_test();
+}
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.pass.cpp
index 0f68926376f2..73d53a4c0e26 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.pass.cpp
@@ -17,15 +17,37 @@
 // UNSUPPORTED: c++98, c++03
 
 #include <tuple>
+#include <memory>
 #include <cassert>
 
 #include "allocators.h"
 #include "../alloc_first.h"
 #include "../alloc_last.h"
 
+struct ImplicitCopy {
+  explicit ImplicitCopy(int) {}
+  ImplicitCopy(ImplicitCopy const&) {}
+};
+
+// Test that tuple(std::allocator_arg, Alloc, Types const&...) allows implicit
+// copy conversions in return value expressions.
+std::tuple<ImplicitCopy> testImplicitCopy1() {
+    ImplicitCopy i(42);
+    return {std::allocator_arg, std::allocator<void>{}, i};
+}
+
+std::tuple<ImplicitCopy> testImplicitCopy2() {
+    const ImplicitCopy i(42);
+    return {std::allocator_arg, std::allocator<void>{}, i};
+}
+
 int main()
 {
     {
+        // check that the literal '0' can implicitly initialize a stored pointer.
+        std::tuple<int*> t = {std::allocator_arg, std::allocator<void>{}, 0};
+    }
+    {
         std::tuple<int> t(std::allocator_arg, A1<int>(), 3);
         assert(std::get<0>(t) == 3);
     }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.fail.cpp
new file mode 100644
index 000000000000..ccf08833b537
--- /dev/null
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.fail.cpp
@@ -0,0 +1,43 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... Types> class tuple;
+
+// template <class Alloc, class ...UTypes>
+//   tuple(allocator_arg_t, const Alloc& a, tuple<UTypes...> const&);
+
+// UNSUPPORTED: c++98, c++03
+
+#include <tuple>
+#include <memory>
+
+struct ExplicitCopy {
+  explicit ExplicitCopy(int) {}
+  explicit ExplicitCopy(ExplicitCopy const&) {}
+
+};
+
+std::tuple<ExplicitCopy> const_explicit_copy_test() {
+    const std::tuple<int> t1(42);
+    return {std::allocator_arg, std::allocator<void>{}, t1};
+    // expected-error@-1 {{chosen constructor is explicit in copy-initialization}}
+}
+
+std::tuple<ExplicitCopy> non_const_explicit_copy_test() {
+    std::tuple<int> t1(42);
+    return {std::allocator_arg, std::allocator<void>{}, t1};
+    // expected-error@-1 {{chosen constructor is explicit in copy-initialization}}
+}
+
+int main()
+{
+
+}
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.pass.cpp
index 8acfde7a98eb..36d9f32879cb 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.pass.cpp
@@ -17,12 +17,23 @@
 // UNSUPPORTED: c++98, c++03
 
 #include <tuple>
+#include <memory>
 #include <cassert>
 
 #include "allocators.h"
 #include "../alloc_first.h"
 #include "../alloc_last.h"
 
+struct Explicit {
+  int value;
+  explicit Explicit(int x) : value(x) {}
+};
+
+struct Implicit {
+  int value;
+  Implicit(int x) : value(x) {}
+};
+
 int main()
 {
     {
@@ -66,4 +77,14 @@ int main()
         assert(std::get<1>(t1) == 2);
         assert(std::get<2>(t1) == 3);
     }
+    {
+        const std::tuple<int> t1(42);
+        std::tuple<Explicit> t2{std::allocator_arg, std::allocator<void>{},  t1};
+        assert(std::get<0>(t2).value == 42);
+    }
+    {
+        const std::tuple<int> t1(42);
+        std::tuple<Implicit> t2 = {std::allocator_arg, std::allocator<void>{}, t1};
+        assert(std::get<0>(t2).value == 42);
+    }
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.fail.cpp
new file mode 100644
index 000000000000..d3539cebf950
--- /dev/null
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.fail.cpp
@@ -0,0 +1,36 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... Types> class tuple;
+
+// template <class Alloc, class ...UTypes>
+//   tuple(allocator_arg_t, const Alloc& a, tuple<UTypes...>&&);
+
+// UNSUPPORTED: c++98, c++03
+
+#include <tuple>
+#include <memory>
+
+struct ExplicitCopy {
+  explicit ExplicitCopy(int) {}
+  explicit ExplicitCopy(ExplicitCopy const&) {}
+};
+
+std::tuple<ExplicitCopy> explicit_move_test() {
+    std::tuple<int> t1(42);
+    return {std::allocator_arg, std::allocator<void>{}, std::move(t1)};
+    // expected-error@-1 {{chosen constructor is explicit in copy-initialization}}
+}
+
+int main()
+{
+
+}
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.pass.cpp
index c862d3b64d56..d3a6add5da6a 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.pass.cpp
@@ -40,6 +40,16 @@ struct D
     explicit D(int i) : B(i) {}
 };
 
+struct Explicit {
+  int value;
+  explicit Explicit(int x) : value(x) {}
+};
+
+struct Implicit {
+  int value;
+  Implicit(int x) : value(x) {}
+};
+
 int main()
 {
     {
@@ -81,4 +91,14 @@ int main()
         assert(std::get<1>(t1) == 2);
         assert(std::get<2>(t1)->id_ == 3);
     }
+    {
+        std::tuple<int> t1(42);
+        std::tuple<Explicit> t2{std::allocator_arg, std::allocator<void>{}, std::move(t1)};
+        assert(std::get<0>(t2).value == 42);
+    }
+    {
+        std::tuple<int> t1(42);
+        std::tuple<Implicit> t2 = {std::allocator_arg, std::allocator<void>{}, std::move(t1)};
+        assert(std::get<0>(t2).value == 42);
+    }
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_copy.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_copy.pass.cpp
index 14e127e59ba9..7c9f60cbf901 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_copy.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_copy.pass.cpp
@@ -52,6 +52,8 @@ int main()
         assert(alloc_last::allocator_constructed);
         assert(std::get<0>(t) == 2);
     }
+// testing extensions
+#ifdef _LIBCPP_VERSION
     {
         typedef std::tuple<alloc_first, alloc_last> T;
         T t0(2, 3);
@@ -75,4 +77,5 @@ int main()
         assert(std::get<1>(t) == 2);
         assert(std::get<2>(t) == 3);
     }
+#endif
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_move.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_move.pass.cpp
index 54d3f7ee0c07..a3e1a9de6195 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_move.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_move.pass.cpp
@@ -53,6 +53,8 @@ int main()
         assert(alloc_last::allocator_constructed);
         assert(std::get<0>(t) == 1);
     }
+// testing extensions
+#ifdef _LIBCPP_VERSION
     {
         typedef std::tuple<MoveOnly, alloc_first> T;
         T t0(0 ,1);
@@ -74,4 +76,5 @@ int main()
         assert(std::get<1>(t) == 2);
         assert(std::get<2>(t) == 3);
     }
+#endif
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.fail.cpp
index 00e2af265b36..b72f0fc2efec 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.fail.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.fail.cpp
@@ -19,9 +19,30 @@
 #include <string>
 #include <cassert>
 
+struct ExplicitCopy {
+  ExplicitCopy(int) {}
+  explicit ExplicitCopy(ExplicitCopy const&) {}
+};
+
+std::tuple<ExplicitCopy> const_explicit_copy() {
+    const ExplicitCopy e(42);
+    return {e};
+    // expected-error@-1 {{chosen constructor is explicit in copy-initialization}}
+}
+
+
+std::tuple<ExplicitCopy> non_const_explicit_copy() {
+    ExplicitCopy e(42);
+    return {e};
+    // expected-error@-1 {{chosen constructor is explicit in copy-initialization}}
+}
+
+std::tuple<ExplicitCopy> const_explicit_copy_no_brace() {
+    const ExplicitCopy e(42);
+    return e;
+    // expected-error@-1 {{no viable conversion}}
+}
+
 int main()
 {
-    {
-        std::tuple<int*> t = 0;
-    }
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.pass.cpp
index bbadf8de1600..367f19e5d8dd 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.pass.cpp
@@ -53,13 +53,40 @@ struct NoValueCtorEmpty
     { static_assert(never<T>::value, "This should not be instantiated"); }
 };
 
+
+struct ImplicitCopy {
+  explicit ImplicitCopy(int) {}
+  ImplicitCopy(ImplicitCopy const&) {}
+};
+
+// Test that tuple(std::allocator_arg, Alloc, Types const&...) allows implicit
+// copy conversions in return value expressions.
+std::tuple<ImplicitCopy> testImplicitCopy1() {
+    ImplicitCopy i(42);
+    return {i};
+}
+
+std::tuple<ImplicitCopy> testImplicitCopy2() {
+    const ImplicitCopy i(42);
+    return {i};
+}
+
+std::tuple<ImplicitCopy> testImplicitCopy3() {
+    const ImplicitCopy i(42);
+    return i;
+}
+
 int main()
 {
     {
+        // check that the literal '0' can implicitly initialize a stored pointer.
+        std::tuple<int*> t = 0;
+    }
+    {
         std::tuple<int> t(2);
         assert(std::get<0>(t) == 2);
     }
-#if _LIBCPP_STD_VER > 11 
+#if _LIBCPP_STD_VER > 11
     {
         constexpr std::tuple<int> t(2);
         static_assert(std::get<0>(t) == 2, "");
@@ -74,7 +101,7 @@ int main()
         assert(std::get<0>(t) == 2);
         assert(std::get<1>(t) == nullptr);
     }
-#if _LIBCPP_STD_VER > 11 
+#if _LIBCPP_STD_VER > 11
     {
         constexpr std::tuple<int, char*> t(2, nullptr);
         static_assert(std::get<0>(t) == 2, "");
@@ -109,7 +136,8 @@ int main()
         assert(std::get<2>(t) == 2);
         assert(std::get<3>(t) == 3);
     }
-    // extensions
+// extensions
+#ifdef _LIBCPP_VERSION
     {
         std::tuple<int, char*, std::string> t(2);
         assert(std::get<0>(t) == 2);
@@ -129,4 +157,5 @@ int main()
         assert(std::get<2>(t) == "text");
         assert(std::get<3>(t) == 0.0);
     }
+#endif
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_pair.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_pair.pass.cpp
index 740b6589e511..d6d489fd0ea4 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_pair.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_pair.pass.cpp
@@ -29,7 +29,7 @@ int main()
         assert(std::get<0>(t1) == 2);
         assert(std::get<1>(t1) == short('a'));
     }
-#if _LIBCPP_STD_VER > 11 
+#if _LIBCPP_STD_VER > 11
     {
         typedef std::pair<double, char> P0;
         typedef std::tuple<int, short> T1;
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_copy.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_copy.pass.cpp
index 5ad4f9227f48..b7fa2e3a03cc 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_copy.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_copy.pass.cpp
@@ -20,6 +20,16 @@
 #include <string>
 #include <cassert>
 
+struct Explicit {
+  int value;
+  explicit Explicit(int x) : value(x) {}
+};
+
+struct Implicit {
+  int value;
+  Implicit(int x) : value(x) {}
+};
+
 struct B
 {
     int id_;
@@ -33,7 +43,7 @@ struct D
     explicit D(int i) : B(i) {}
 };
 
-#if _LIBCPP_STD_VER > 11 
+#if _LIBCPP_STD_VER > 11
 
 struct A
 {
@@ -62,7 +72,7 @@ int main()
         T1 t1 = t0;
         assert(std::get<0>(t1) == 2);
     }
-#if _LIBCPP_STD_VER > 11 
+#if _LIBCPP_STD_VER > 11
     {
         typedef std::tuple<double> T0;
         typedef std::tuple<A> T1;
@@ -115,4 +125,14 @@ int main()
         assert(std::get<1>(t1) == int('a'));
         assert(std::get<2>(t1).id_ == 3);
     }
+    {
+        const std::tuple<int> t1(42);
+        std::tuple<Explicit> t2(t1);
+        assert(std::get<0>(t2).value == 42);
+    }
+    {
+        const std::tuple<int> t1(42);
+        std::tuple<Implicit> t2 = t1;
+        assert(std::get<0>(t2).value == 42);
+    }
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_move.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_move.pass.cpp
index 3a6abd3a95af..8423f5d0145f 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_move.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_move.pass.cpp
@@ -20,6 +20,16 @@
 #include <memory>
 #include <cassert>
 
+struct Explicit {
+  int value;
+  explicit Explicit(int x) : value(x) {}
+};
+
+struct Implicit {
+  int value;
+  Implicit(int x) : value(x) {}
+};
+
 struct B
 {
     int id_;
@@ -81,4 +91,14 @@ int main()
         assert(std::get<1>(t1) == int('a'));
         assert(std::get<2>(t1)->id_ == 3);
     }
+    {
+        std::tuple<int> t1(42);
+        std::tuple<Explicit> t2(std::move(t1));
+        assert(std::get<0>(t2).value == 42);
+    }
+    {
+        std::tuple<int> t1(42);
+        std::tuple<Implicit> t2 = std::move(t1);
+        assert(std::get<0>(t2).value == 42);
+    }
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/move.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/move.pass.cpp
index 0cda96846f71..1bd7d6d4e8a8 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/move.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/move.pass.cpp
@@ -29,8 +29,10 @@ struct ConstructsWithTupleLeaf
     ConstructsWithTupleLeaf(ConstructsWithTupleLeaf &&) {}
 
     template <class T>
-    ConstructsWithTupleLeaf(T t)
-    { assert(false); }
+    ConstructsWithTupleLeaf(T t) {
+        static_assert(!std::is_same<T, T>::value,
+                      "Constructor instantiated for type other than int");
+    }
 };
 
 int main()
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/test_lazy_sfinae.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/test_lazy_sfinae.pass.cpp
new file mode 100644
index 000000000000..76f7e794a8e8
--- /dev/null
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/test_lazy_sfinae.pass.cpp
@@ -0,0 +1,102 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... Types> class tuple;
+
+// UNSUPPORTED: c++98, c++03
+
+#include <tuple>
+#include <utility>
+#include <cassert>
+
+template <class ConstructFrom>
+struct ConstructibleFromT {
+  ConstructibleFromT() = default;
+  ConstructibleFromT(ConstructFrom v) : value(v) {}
+  ConstructFrom value;
+};
+
+template <class AssertOn>
+struct CtorAssertsT {
+  bool defaulted;
+  CtorAssertsT() : defaulted(true) {}
+  template <class T>
+  constexpr CtorAssertsT(T) : defaulted(false) {
+      static_assert(!std::is_same<T, AssertOn>::value, "");
+  }
+};
+
+template <class AllowT, class AssertT>
+struct AllowAssertT {
+  AllowAssertT() = default;
+  AllowAssertT(AllowT) {}
+  template <class U>
+  constexpr AllowAssertT(U) {
+      static_assert(!std::is_same<U, AssertT>::value, "");
+  }
+};
+
+// Construct a tuple<T1, T2> from pair<int, int> where T1 and T2
+// are not constructible from ints but T1 is constructible from std::pair.
+// This considers the following constructors:
+// (1) tuple(TupleLike) -> checks is_constructible<Tn, int>
+// (2) tuple(UTypes...) -> checks is_constructible<T1, pair<int, int>>
+//                            and is_default_constructible<T2>
+// The point of this test is to ensure that the consideration of (1)
+// short circuits before evaluating is_constructible<T2, int>, which
+// will cause a static assertion.
+void test_tuple_like_lazy_sfinae() {
+#if defined(_LIBCPP_VERSION)
+    // This test requires libc++'s reduced arity initialization.
+    using T1 = ConstructibleFromT<std::pair<int, int>>;
+    using T2 = CtorAssertsT<int>;
+    std::pair<int, int> p(42, 100);
+    std::tuple<T1, T2> t(p);
+    assert(std::get<0>(t).value == p);
+    assert(std::get<1>(t).defaulted);
+#endif
+}
+
+
+struct NonConstCopyable {
+  NonConstCopyable() = default;
+  explicit NonConstCopyable(int v) : value(v) {}
+  NonConstCopyable(NonConstCopyable&) = default;
+  NonConstCopyable(NonConstCopyable const&) = delete;
+  int value;
+};
+
+template <class T>
+struct BlowsUpOnConstCopy {
+  BlowsUpOnConstCopy() = default;
+  constexpr BlowsUpOnConstCopy(BlowsUpOnConstCopy const&) {
+      static_assert(!std::is_same<T, T>::value, "");
+  }
+  BlowsUpOnConstCopy(BlowsUpOnConstCopy&) = default;
+};
+
+// Test the following constructors:
+// (1) tuple(Types const&...)
+// (2) tuple(UTypes&&...)
+// Test that (1) short circuits before evaluating the copy constructor of the
+// second argument. Constructor (2) should be selected.
+void test_const_Types_lazy_sfinae()
+{
+    NonConstCopyable v(42);
+    BlowsUpOnConstCopy<int> b;
+    std::tuple<NonConstCopyable, BlowsUpOnConstCopy<int>> t(v, b);
+    assert(std::get<0>(t).value == 42);
+}
+
+int main() {
+    test_tuple_like_lazy_sfinae();
+    test_const_Types_lazy_sfinae();
+}
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.creation/forward_as_tuple.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.creation/forward_as_tuple.pass.cpp
index 0e556b1b6c8e..2dbe81513a1a 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.creation/forward_as_tuple.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.creation/forward_as_tuple.pass.cpp
@@ -20,7 +20,7 @@
 
 template <class Tuple>
 void
-test0(const Tuple& t)
+test0(const Tuple&)
 {
     static_assert(std::tuple_size<Tuple>::value == 0, "");
 }
@@ -56,8 +56,8 @@ test2a(const Tuple& t)
 
 #if _LIBCPP_STD_VER > 11
 template <class Tuple>
-constexpr int 
-test3(const Tuple& t)
+constexpr int
+test3(const Tuple&)
 {
     return std::tuple_size<Tuple>::value;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.creation/make_tuple.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.creation/make_tuple.pass.cpp
index 2ee96dc7ebf4..f27e8a09fb97 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.creation/make_tuple.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.creation/make_tuple.pass.cpp
@@ -40,7 +40,7 @@ int main()
         assert(i == 0);
         assert(j == 0);
     }
-#if _LIBCPP_STD_VER > 11 
+#if _LIBCPP_STD_VER > 11
     {
         constexpr auto t1 = std::make_tuple(0, 1, 3.14);
         constexpr int i1 = std::get<1>(t1);
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const.pass.cpp
index e21768cb6f5f..002ad148ad6d 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const.pass.cpp
@@ -36,7 +36,7 @@ int main()
         assert(std::get<0>(t) == "high");
         assert(std::get<1>(t) == 5);
     }
-#if _LIBCPP_STD_VER > 11 
+#if _LIBCPP_STD_VER > 11
     {
         typedef std::tuple<double, int> T;
         constexpr T t(2.718, 5);
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_non_const.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_non_const.pass.cpp
index 1c2b17ad8832..86d1191db556 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_non_const.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_non_const.pass.cpp
@@ -21,7 +21,9 @@
 #include <string>
 #include <cassert>
 
-#if __cplusplus > 201103L
+#include "test_macros.h"
+
+#if TEST_STD_VER > 11
 
 struct Empty {};
 
@@ -69,7 +71,7 @@ int main()
         assert(std::get<2>(t) == 4);
         assert(d == 2.5);
     }
-#if _LIBCPP_STD_VER > 11 
+#if _LIBCPP_STD_VER > 11
     { // get on an rvalue tuple
         static_assert ( std::get<0> ( std::make_tuple ( 0.0f, 1, 2.0, 3L )) == 0, "" );
         static_assert ( std::get<1> ( std::make_tuple ( 0.0f, 1, 2.0, 3L )) == 1, "" );
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.fail.cpp
new file mode 100644
index 000000000000..74e6efd983bd
--- /dev/null
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.fail.cpp
@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11
+
+#include <tuple>
+#include <string>
+
+struct UserType {};
+
+void test_bad_index() {
+    std::tuple<long, long, char, std::string, char, UserType, char> t1;
+    (void)std::get<int>(t1); // expected-error@tuple:* {{type not found}}
+    (void)std::get<long>(t1); // expected-note {{requested here}}
+    (void)std::get<char>(t1); // expected-note {{requested here}}
+        // expected-error@tuple:* 2 {{type occurs more than once}}
+    std::tuple<> t0;
+    (void)std::get<char*>(t0); // expected-node {{requested here}}
+        // expected-error@tuple:* 1 {{type not in empty type list}}
+}
+
+void test_bad_return_type() {
+    typedef std::unique_ptr<int> upint;
+    std::tuple<upint> t;
+    upint p = std::get<upint>(t); // expected-error{{deleted copy constructor}}
+}
+
+int main()
+{
+    test_bad_index();
+    test_bad_return_type();
+}
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.pass.cpp
index b661a78de8db..01ee1ca1f434 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.pass.cpp
@@ -11,6 +11,7 @@
 
 #include <tuple>
 #include <utility>
+#include <memory>
 #include <string>
 #include <complex>
 #include <type_traits>
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.array.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.array.pass.cpp
index d8a72c617cb5..57da4b04cdfd 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.array.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.array.pass.cpp
@@ -18,7 +18,7 @@
 //     typedef Ti type;
 // };
 //
-//  LWG #2212 says that tuple_size and tuple_element must be 
+//  LWG #2212 says that tuple_size and tuple_element must be
 //     available after including <utility>
 
 #include <array>
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.utility.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.utility.pass.cpp
index 8c8357d95d99..bd015ab5bbd6 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.utility.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.utility.pass.cpp
@@ -15,9 +15,10 @@
 //   class tuple_size<tuple<Types...>>
 //     : public integral_constant<size_t, sizeof...(Types)> { };
 //
-//  LWG #2212 says that tuple_size and tuple_element must be 
+//  LWG #2212 says that tuple_size and tuple_element must be
 //     available after including <utility>
 
+#include <cstddef>
 #include <utility>
 #include <type_traits>
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.fail.cpp
new file mode 100644
index 000000000000..4cb73573e7c9
--- /dev/null
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.fail.cpp
@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... Types> class tuple;
+
+// template <size_t I, class... Types>
+// class tuple_element<I, tuple<Types...> >
+// {
+// public:
+//     typedef Ti type;
+// };
+
+// UNSUPPORTED: c++98, c++03
+
+#include <tuple>
+#include <type_traits>
+
+int main()
+{
+    using T =  std::tuple<int, long, void*>;
+    using E1 = typename std::tuple_element<1, T &>::type; // expected-error{{undefined template}}
+    using E2 = typename std::tuple_element<3, T>::type;
+    using E3 = typename std::tuple_element<4, T const>::type;
+        // expected-error@__tuple:* 2 {{static_assert failed}}
+
+}
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size.fail.cpp
new file mode 100644
index 000000000000..3f132e47b626
--- /dev/null
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size.fail.cpp
@@ -0,0 +1,27 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <tuple>
+
+// template <class... Types>
+//   class tuple_size<tuple<Types...>>
+//     : public integral_constant<size_t, sizeof...(Types)> { };
+
+// Expect failures with a reference type, pointer type, and a non-tuple type.
+
+#include <tuple>
+
+int main()
+{
+    (void)std::tuple_size<std::tuple<> &>::value; // expected-error {{implicit instantiation of undefined template}}
+    (void)std::tuple_size<int>::value; // expected-error {{implicit instantiation of undefined template}}
+    (void)std::tuple_size<std::tuple<>*>::value; // expected-error {{implicit instantiation of undefined template}}
+}
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_v.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_v.fail.cpp
new file mode 100644
index 000000000000..957a683b47f8
--- /dev/null
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_v.fail.cpp
@@ -0,0 +1,26 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11, c++14
+
+// <tuple>
+
+// template <class T> constexpr size_t tuple_size_v = tuple_size<T>::value;
+
+// Expect failures with a reference type, pointer type, and a non-tuple type.
+
+#include <tuple>
+
+int main()
+{
+    (void)std::tuple_size_v<std::tuple<> &>; // expected-note {{requested here}}
+    (void)std::tuple_size_v<int>; // expected-note {{requested here}}
+    (void)std::tuple_size_v<std::tuple<>*>; // expected-note {{requested here}}
+    // expected-error@tuple:* 3 {{implicit instantiation of undefined template}}
+}
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_v.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_v.pass.cpp
new file mode 100644
index 000000000000..24878a1d560e
--- /dev/null
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_v.pass.cpp
@@ -0,0 +1,43 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++11, c++14
+
+// <tuple>
+
+// template <class T> constexpr size_t tuple_size_v = tuple_size<T>::value;
+
+#include <tuple>
+#include <utility>
+#include <array>
+
+template <class Tuple, int Expect>
+void test()
+{
+    static_assert(std::tuple_size_v<Tuple> == Expect, "");
+    static_assert(std::tuple_size_v<Tuple> == std::tuple_size<Tuple>::value, "");
+    static_assert(std::tuple_size_v<Tuple const> == std::tuple_size<Tuple>::value, "");
+    static_assert(std::tuple_size_v<Tuple volatile> == std::tuple_size<Tuple>::value, "");
+    static_assert(std::tuple_size_v<Tuple const volatile> == std::tuple_size<Tuple>::value, "");
+}
+
+int main()
+{
+    test<std::tuple<>, 0>();
+
+    test<std::tuple<int>, 1>();
+    test<std::array<int, 1>, 1>();
+
+    test<std::tuple<int, int>, 2>();
+    test<std::pair<int, int>, 2>();
+    test<std::array<int, 2>, 2>();
+
+    test<std::tuple<int, int, int>, 3>();
+    test<std::array<int, 3>, 3>();
+}
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.rel/eq.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.rel/eq.pass.cpp
index 0d25edc4547b..e5991df636f8 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.rel/eq.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.rel/eq.pass.cpp
@@ -143,7 +143,7 @@ int main()
         assert(!(t1 == t2));
         assert(t1 != t2);
     }
-#if _LIBCPP_STD_VER > 11 
+#if _LIBCPP_STD_VER > 11
     {
         typedef std::tuple<char, int, double> T1;
         typedef std::tuple<double, char, int> T2;
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.rel/lt.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.rel/lt.pass.cpp
index eac84a9c35f6..34aafb1e1347 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.rel/lt.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.rel/lt.pass.cpp
@@ -195,7 +195,7 @@ int main()
         assert(!(t1 >  t2));
         assert(!(t1 >= t2));
     }
-#if _LIBCPP_STD_VER > 11 
+#if _LIBCPP_STD_VER > 11
     {
         typedef std::tuple<char, int, double> T1;
         typedef std::tuple<double, char, int> T2;
diff --git a/test/std/utilities/utility/as_const/as_const.pass.cpp b/test/std/utilities/utility/as_const/as_const.pass.cpp
index ff3f84a5532f..7bb5849d0bd0 100644
--- a/test/std/utilities/utility/as_const/as_const.pass.cpp
+++ b/test/std/utilities/utility/as_const/as_const.pass.cpp
@@ -27,7 +27,7 @@ void test(T& t)
     static_assert(std::is_const<typename std::remove_reference<decltype(std::as_const<const          T>(t))>::type>::value, "");
     static_assert(std::is_const<typename std::remove_reference<decltype(std::as_const<volatile       T>(t))>::type>::value, "");
     static_assert(std::is_const<typename std::remove_reference<decltype(std::as_const<const volatile T>(t))>::type>::value, "");
-    
+
     assert(std::as_const(t) == t);
     assert(std::as_const<               T>(t) == t);
     assert(std::as_const<const          T>(t) == t);
diff --git a/test/std/utilities/utility/exchange/exchange.pass.cpp b/test/std/utilities/utility/exchange/exchange.pass.cpp
index 620b4149d1d0..5ef0ac3b09f5 100644
--- a/test/std/utilities/utility/exchange/exchange.pass.cpp
+++ b/test/std/utilities/utility/exchange/exchange.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // utilities
 
 // exchange
@@ -17,7 +18,6 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     {
     int v = 12;
     assert ( std::exchange ( v, 23 ) == 12 );
@@ -27,7 +27,7 @@ int main()
 
     assert ((std::exchange<int, float> ( v, {} )) == 67 );
     assert ( v == 0 );
-    
+
     }
 
     {
@@ -48,11 +48,9 @@ int main()
     s3 = s2; // Dad
     assert ( std::exchange ( s3, {} ) == s2 );
     assert ( s3.size () == 0 );
-    
+
     s3 = s2; // Dad
     assert ( std::exchange ( s3, "" ) == s2 );
     assert ( s3.size () == 0 );
     }
-
-#endif
 }
diff --git a/test/std/utilities/utility/forward/forward.pass.cpp b/test/std/utilities/utility/forward/forward.pass.cpp
index 357b36fafa96..94575485df04 100644
--- a/test/std/utilities/utility/forward/forward.pass.cpp
+++ b/test/std/utilities/utility/forward/forward.pass.cpp
@@ -39,6 +39,9 @@ int main()
     A a;
     const A ca = A();
 
+    ((void)a); // Prevent unused warning
+    ((void)ca); // Prevent unused warning
+
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     static_assert(sizeof(test(std::forward<A&>(a))) == 1, "");
     static_assert(sizeof(test(std::forward<A>(a))) == 4, "");
diff --git a/test/std/utilities/utility/pairs/pair.astuple/get_const.pass.cpp b/test/std/utilities/utility/pairs/pair.astuple/get_const.pass.cpp
index fcda3664d9b6..9ef7bcff2ba8 100644
--- a/test/std/utilities/utility/pairs/pair.astuple/get_const.pass.cpp
+++ b/test/std/utilities/utility/pairs/pair.astuple/get_const.pass.cpp
@@ -18,6 +18,8 @@
 #include <utility>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
     {
@@ -27,7 +29,7 @@ int main()
         assert(std::get<1>(p) == 4);
     }
 
-#if __cplusplus > 201103L
+#if TEST_STD_VER > 11
     {
         typedef std::pair<int, short> P;
         constexpr P p1(3, 4);
diff --git a/test/std/utilities/utility/pairs/pair.astuple/get_non_const.pass.cpp b/test/std/utilities/utility/pairs/pair.astuple/get_non_const.pass.cpp
index 6d61c47ffbf0..47b4c06134d9 100644
--- a/test/std/utilities/utility/pairs/pair.astuple/get_non_const.pass.cpp
+++ b/test/std/utilities/utility/pairs/pair.astuple/get_non_const.pass.cpp
@@ -18,7 +18,9 @@
 #include <utility>
 #include <cassert>
 
-#if __cplusplus > 201103L
+#include "test_macros.h"
+
+#if TEST_STD_VER > 11
 struct S {
    std::pair<int, int> a;
    int k;
@@ -41,7 +43,7 @@ int main()
         assert(std::get<1>(p) == 6);
     }
 
-#if __cplusplus > 201103L
+#if TEST_STD_VER > 11
     {
         static_assert(S().k == 1, "");
         static_assert(std::get<1>(getP()) == 4, "");
diff --git a/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type1.fail.cpp b/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type1.fail.cpp
index 27194effe5c3..f0d55a661822 100644
--- a/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type1.fail.cpp
+++ b/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type1.fail.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 #include <utility>
 #include <complex>
 
@@ -14,11 +15,7 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     typedef std::complex<float> cf;
     auto t1 = std::make_pair<int, double> ( 42, 3.4 );
     assert (( std::get<cf>(t1) == cf {1,2} ));  // no such type
-#else
-#error
-#endif
 }
diff --git a/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type2.fail.cpp b/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type2.fail.cpp
index f9e3942d7e77..72e637592483 100644
--- a/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type2.fail.cpp
+++ b/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type2.fail.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 #include <utility>
 #include <complex>
 
@@ -14,11 +15,7 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     typedef std::complex<float> cf;
     auto t1 = std::make_pair<int, int> ( 42, 43 );
     assert ( std::get<int>(t1) == 42 ); // two ints
-#else
-#error
-#endif
 }
diff --git a/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type3.fail.cpp b/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type3.fail.cpp
index 484347345747..d5179e4355b9 100644
--- a/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type3.fail.cpp
+++ b/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type3.fail.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 #include <utility>
 #include <complex>
 
@@ -14,11 +15,7 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11
     typedef std::unique_ptr<int> upint;
     std::pair<upint, int> t(upint(new int(4)), 23);
     upint p = std::get<upint>(t);
-#else
-#error
-#endif
 }
diff --git a/test/std/utilities/utility/pairs/pairs.pair/copy_ctor.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/copy_ctor.pass.cpp
index 4b54f717045a..1117db3297b8 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/copy_ctor.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/copy_ctor.pass.cpp
@@ -16,6 +16,8 @@
 #include <utility>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
     {
@@ -25,10 +27,7 @@ int main()
         assert(p2.first == 3);
         assert(p2.second == 4);
     }
-
-    static_assert((std::is_trivially_copy_constructible<std::pair<int, int> >::value), "");
-
-#if _LIBCPP_STD_VER > 11
+#if TEST_STD_VER > 11
     {
         typedef std::pair<int, short> P1;
         constexpr P1 p1(3, 4);
diff --git a/test/std/utilities/utility/pairs/pairs.pair/default.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/default.pass.cpp
index d83328b8f2d0..97182d24d021 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/default.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/default.pass.cpp
@@ -13,9 +13,15 @@
 
 // constexpr pair();
 
+// This test doesn't pass due to a constexpr bug in GCC 4.9 that fails
+// to initialize any type without a user provided constructor in a constant
+// expression (ie float).
+// XFAIL: gcc-4.9
+
 // NOTE: The SFINAE on the default constructor is tested in
 //       default-sfinae.pass.cpp
 
+
 #include <utility>
 #include <type_traits>
 #include <cassert>
diff --git a/test/std/utilities/utility/pairs/pairs.pair/move_ctor.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/move_ctor.pass.cpp
new file mode 100644
index 000000000000..06cb5e5658c9
--- /dev/null
+++ b/test/std/utilities/utility/pairs/pairs.pair/move_ctor.pass.cpp
@@ -0,0 +1,44 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <utility>
+
+// template <class T1, class T2> struct pair
+
+// pair(pair&&) = default;
+
+#include <utility>
+#include <memory>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct Dummy {
+  Dummy(Dummy const&) = delete;
+  Dummy(Dummy &&) = default;
+};
+
+int main()
+{
+    {
+        typedef std::pair<int, short> P1;
+        static_assert(std::is_move_constructible<P1>::value, "");
+        P1 p1(3, 4);
+        P1 p2 = std::move(p1);
+        assert(p2.first == 3);
+        assert(p2.second == 4);
+    }
+    {
+        using P = std::pair<Dummy, int>;
+        static_assert(!std::is_copy_constructible<P>::value, "");
+        static_assert(std::is_move_constructible<P>::value, "");
+    }
+}
diff --git a/test/std/utilities/utility/pairs/pairs.pair/swap.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/swap.pass.cpp
index 0ad5786bce29..dfea61eeacdb 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/swap.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/swap.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 
 struct S {
-    int i; 
+    int i;
     S() : i(0) {}
     S(int j) : i(j) {}
     S * operator& () { assert(false); return this; }
diff --git a/test/std/utilities/utility/pairs/pairs.pair/trivial_copy_move.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/trivial_copy_move.pass.cpp
new file mode 100644
index 000000000000..53cf56700df8
--- /dev/null
+++ b/test/std/utilities/utility/pairs/pairs.pair/trivial_copy_move.pass.cpp
@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <utility>
+
+// template <class T1, class T2> struct pair
+
+// pair(pair const&) = default;
+// pair(pair&&) = default;
+
+// Doesn't pass due to use of is_trivially_* trait.
+// XFAIL: gcc-4.9
+
+#include <utility>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct Dummy {
+  Dummy(Dummy const&) = delete;
+  Dummy(Dummy &&) = default;
+};
+
+int main()
+{
+    typedef std::pair<int, short> P;
+    {
+        static_assert(std::is_copy_constructible<P>::value, "");
+        static_assert(std::is_trivially_copy_constructible<P>::value, "");
+    }
+#if TEST_STD_VER >= 11
+    {
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(std::is_trivially_move_constructible<P>::value, "");
+    }
+    {
+        using P1 = std::pair<Dummy, int>;
+        static_assert(!std::is_copy_constructible<P1>::value, "");
+        static_assert(!std::is_trivially_copy_constructible<P1>::value, "");
+        static_assert(std::is_move_constructible<P1>::value, "");
+        static_assert(std::is_trivially_move_constructible<P1>::value, "");
+    }
+#endif
+}
diff --git a/test/std/utilities/utility/pairs/pairs.spec/make_pair.pass.cpp b/test/std/utilities/utility/pairs/pairs.spec/make_pair.pass.cpp
index 48e09735abb0..4a6d71e7b9c8 100644
--- a/test/std/utilities/utility/pairs/pairs.spec/make_pair.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.spec/make_pair.pass.cpp
@@ -23,7 +23,7 @@ int main()
         assert(p1.first == 3);
         assert(p1.second == 4);
     }
-    
+
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
         typedef std::pair<std::unique_ptr<int>, short> P1;
diff --git a/test/std/utilities/utility/synopsis.pass.cpp b/test/std/utilities/utility/synopsis.pass.cpp
new file mode 100644
index 000000000000..5f5b4eeaad52
--- /dev/null
+++ b/test/std/utilities/utility/synopsis.pass.cpp
@@ -0,0 +1,21 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <utility>
+// XFAIL: c++98, c++03
+
+// #include <initializer_list>
+
+#include <utility>
+
+int main()
+{
+    std::initializer_list<int> x;
+}
+
diff --git a/test/std/utilities/utility/utility.swap/swap.pass.cpp b/test/std/utilities/utility/utility.swap/swap.pass.cpp
index 8606611f6603..c9c9f3b52760 100644
--- a/test/std/utilities/utility/utility.swap/swap.pass.cpp
+++ b/test/std/utilities/utility/utility.swap/swap.pass.cpp
@@ -16,38 +16,88 @@
 
 #include <utility>
 #include <cassert>
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 #include <memory>
-#endif
 
-void
-test()
-{
-    int i = 1;
-    int j = 2;
-    std::swap(i, j);
-    assert(i == 2);
-    assert(j == 1);
-}
+#include "test_macros.h"
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#if TEST_STD_VER >= 11
+struct CopyOnly {
+    CopyOnly() {}
+    CopyOnly(CopyOnly const&) noexcept {}
+    CopyOnly& operator=(CopyOnly const&) { return *this; }
+};
 
-void
-test1()
-{
-    std::unique_ptr<int> i(new int(1));
-    std::unique_ptr<int> j(new int(2));
-    std::swap(i, j);
-    assert(*i == 2);
-    assert(*j == 1);
-}
+struct MoveOnly {
+    MoveOnly() {}
+    MoveOnly(MoveOnly&&) {}
+    MoveOnly& operator=(MoveOnly&&) noexcept { return *this; }
+};
+
+struct NoexceptMoveOnly {
+    NoexceptMoveOnly() {}
+    NoexceptMoveOnly(NoexceptMoveOnly&&) noexcept {}
+    NoexceptMoveOnly& operator=(NoexceptMoveOnly&&) noexcept { return *this; }
+};
+
+struct NotMoveConstructible {
+    NotMoveConstructible& operator=(NotMoveConstructible&&) { return *this; }
+private:
+    NotMoveConstructible(NotMoveConstructible&&);
+};
+
+struct NotMoveAssignable {
+    NotMoveAssignable(NotMoveAssignable&&);
+private:
+    NotMoveAssignable& operator=(NotMoveAssignable&&);
+};
+
+template <class Tp>
+auto can_swap_test(int) -> decltype(std::swap(std::declval<Tp>(), std::declval<Tp>()));
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+template <class Tp>
+auto can_swap_test(...) -> std::false_type;
+
+template <class Tp>
+constexpr bool can_swap() {
+    return std::is_same<decltype(can_swap_test<Tp>(0)), void>::value;
+}
+#endif
 
 int main()
 {
-    test();
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    test1();
+
+    {
+        int i = 1;
+        int j = 2;
+        std::swap(i, j);
+        assert(i == 2);
+        assert(j == 1);
+    }
+#if TEST_STD_VER >= 11
+    {
+
+        std::unique_ptr<int> i(new int(1));
+        std::unique_ptr<int> j(new int(2));
+        std::swap(i, j);
+        assert(*i == 2);
+        assert(*j == 1);
+
+    }
+    {
+        // test that the swap
+        static_assert(can_swap<CopyOnly&>(), "");
+        static_assert(can_swap<MoveOnly&>(), "");
+        static_assert(can_swap<NoexceptMoveOnly&>(), "");
+
+        static_assert(!can_swap<NotMoveConstructible&>(), "");
+        static_assert(!can_swap<NotMoveAssignable&>(), "");
+
+        CopyOnly c;
+        MoveOnly m;
+        NoexceptMoveOnly nm;
+        static_assert(!noexcept(std::swap(c, c)), "");
+        static_assert(!noexcept(std::swap(m, m)), "");
+        static_assert(noexcept(std::swap(nm, nm)), "");
+    }
 #endif
 }
diff --git a/test/std/utilities/utility/utility.swap/swap_array.pass.cpp b/test/std/utilities/utility/utility.swap/swap_array.pass.cpp
index b1209c3c3651..ad39934b20ca 100644
--- a/test/std/utilities/utility/utility.swap/swap_array.pass.cpp
+++ b/test/std/utilities/utility/utility.swap/swap_array.pass.cpp
@@ -16,50 +16,86 @@
 
 #include <utility>
 #include <cassert>
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 #include <memory>
-#endif
 
-void
-test()
-{
-    int i[3] = {1, 2, 3};
-    int j[3] = {4, 5, 6};
-    std::swap(i, j);
-    assert(i[0] == 4);
-    assert(i[1] == 5);
-    assert(i[2] == 6);
-    assert(j[0] == 1);
-    assert(j[1] == 2);
-    assert(j[2] == 3);
-}
+#include "test_macros.h"
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
-void
-test1()
-{
-    std::unique_ptr<int> i[3];
-    for (int k = 0; k < 3; ++k)
-        i[k].reset(new int(k+1));
-    std::unique_ptr<int> j[3];
-    for (int k = 0; k < 3; ++k)
-        j[k].reset(new int(k+4));
-    std::swap(i, j);
-    assert(*i[0] == 4);
-    assert(*i[1] == 5);
-    assert(*i[2] == 6);
-    assert(*j[0] == 1);
-    assert(*j[1] == 2);
-    assert(*j[2] == 3);
+#if TEST_STD_VER >= 11
+struct CopyOnly {
+    CopyOnly() {}
+    CopyOnly(CopyOnly const&) noexcept {}
+    CopyOnly& operator=(CopyOnly const&) { return *this; }
+};
+
+
+struct NoexceptMoveOnly {
+    NoexceptMoveOnly() {}
+    NoexceptMoveOnly(NoexceptMoveOnly&&) noexcept {}
+    NoexceptMoveOnly& operator=(NoexceptMoveOnly&&) noexcept { return *this; }
+};
+
+struct NotMoveConstructible {
+    NotMoveConstructible() {}
+    NotMoveConstructible& operator=(NotMoveConstructible&&) { return *this; }
+private:
+    NotMoveConstructible(NotMoveConstructible&&);
+};
+
+template <class Tp>
+auto can_swap_test(int) -> decltype(std::swap(std::declval<Tp>(), std::declval<Tp>()));
+
+template <class Tp>
+auto can_swap_test(...) -> std::false_type;
+
+template <class Tp>
+constexpr bool can_swap() {
+    return std::is_same<decltype(can_swap_test<Tp>(0)), void>::value;
 }
+#endif
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 int main()
 {
-    test();
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    test1();
+    {
+        int i[3] = {1, 2, 3};
+        int j[3] = {4, 5, 6};
+        std::swap(i, j);
+        assert(i[0] == 4);
+        assert(i[1] == 5);
+        assert(i[2] == 6);
+        assert(j[0] == 1);
+        assert(j[1] == 2);
+        assert(j[2] == 3);
+    }
+#if TEST_STD_VER >= 11
+    {
+        std::unique_ptr<int> i[3];
+        for (int k = 0; k < 3; ++k)
+            i[k].reset(new int(k+1));
+        std::unique_ptr<int> j[3];
+        for (int k = 0; k < 3; ++k)
+            j[k].reset(new int(k+4));
+        std::swap(i, j);
+        assert(*i[0] == 4);
+        assert(*i[1] == 5);
+        assert(*i[2] == 6);
+        assert(*j[0] == 1);
+        assert(*j[1] == 2);
+        assert(*j[2] == 3);
+    }
+    {
+        using CA = CopyOnly[42];
+        using MA = NoexceptMoveOnly[42];
+        using NA = NotMoveConstructible[42];
+        static_assert(can_swap<CA&>(), "");
+        static_assert(can_swap<MA&>(), "");
+        static_assert(!can_swap<NA&>(), "");
+
+        CA ca;
+        MA ma;
+        static_assert(!noexcept(std::swap(ca, ca)), "");
+        static_assert(noexcept(std::swap(ma, ma)), "");
+    }
 #endif
 }
diff --git a/test/support/Counter.h b/test/support/Counter.h
index 2bc3642f5059..eb6e04e72ef6 100644
--- a/test/support/Counter.h
+++ b/test/support/Counter.h
@@ -13,7 +13,7 @@
 #include <functional> // for std::hash
 
 struct Counter_base { static int gConstructed; };
-    
+
 template <typename T>
 class Counter : public Counter_base
 {
@@ -27,7 +27,7 @@ public:
     Counter& operator=(Counter&& rhs) { ++gConstructed; data_ = std::move(rhs.data_); return *this; }
 #endif
     ~Counter() { --gConstructed; }
-    
+
     const T& get() const {return data_;}
 
     bool operator==(const Counter& x) const {return data_ == x.data_;}
diff --git a/test/support/MoveOnly.h b/test/support/MoveOnly.h
index ee6ae7c7e5f9..a3e9cca89ee5 100644
--- a/test/support/MoveOnly.h
+++ b/test/support/MoveOnly.h
@@ -10,6 +10,8 @@
 #ifndef MOVEONLY_H
 #define MOVEONLY_H
 
+#include "test_macros.h"
+
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 #include <cstddef>
diff --git a/test/support/allocators.h b/test/support/allocators.h
index 7c2103ff2721..4aa467f824aa 100644
--- a/test/support/allocators.h
+++ b/test/support/allocators.h
@@ -101,7 +101,7 @@ public:
     A2& operator=(const A2& a) TEST_NOEXCEPT { id_ = a.id(); copy_called = true; return *this;}
     A2& operator=(A2&& a)      TEST_NOEXCEPT { id_ = a.id(); move_called = true; return *this;}
 
-    T* allocate(std::size_t n, const void* hint)
+    T* allocate(std::size_t, const void* hint)
     {
         allocate_called = true;
         return (T*)hint;
diff --git a/test/support/asan_testing.h b/test/support/asan_testing.h
index 45ad04b1bb2c..678f12a91b65 100644
--- a/test/support/asan_testing.h
+++ b/test/support/asan_testing.h
@@ -10,12 +10,12 @@
 #ifndef ASAN_TESTING_H
 #define ASAN_TESTING_H
 
-#include <__config>
+#include "test_macros.h"
 
-#ifndef _LIBCPP_HAS_NO_ASAN
+#if TEST_HAS_FEATURE(address_sanitizer)
 extern "C" int __sanitizer_verify_contiguous_container
      ( const void *beg, const void *mid, const void *end );
-     
+
 template <typename T, typename Alloc>
 bool is_contiguous_container_asan_correct ( const std::vector<T, Alloc> &c )
 {
@@ -27,11 +27,11 @@ bool is_contiguous_container_asan_correct ( const std::vector<T, Alloc> &c )
 
 #else
 template <typename T, typename Alloc>
-bool is_contiguous_container_asan_correct ( const std::vector<T, Alloc> &c )
+bool is_contiguous_container_asan_correct ( const std::vector<T, Alloc> &)
 {
     return true;
 }
 #endif
- 
+
 
 #endif  // ASAN_TESTING_H
diff --git a/test/support/assert_checkpoint.h b/test/support/assert_checkpoint.h
new file mode 100644
index 000000000000..6627b35eb30d
--- /dev/null
+++ b/test/support/assert_checkpoint.h
@@ -0,0 +1,73 @@
+#ifndef SUPPORT_ASSERT_CHECKPOINT_H
+#define SUPPORT_ASSERT_CHECKPOINT_H
+
+#include <csignal>
+#include <iostream>
+#include <cstdlib>
+
+struct Checkpoint {
+  const char* file;
+  const char* func;
+  int line;
+  const char* msg;
+
+  Checkpoint() : file(nullptr), func(nullptr), line(-1), msg(nullptr) {}
+  Checkpoint(const char* xfile, const char* xfunc, int xline, const char* xmsg)
+      : file(xfile), func(xfunc), line(xline), msg(xmsg)
+  {}
+
+  template <class Stream>
+  void print(Stream& s) const {
+      if (!file) {
+          s << "NO CHECKPOINT\n";
+          return;
+      }
+      s << file << ":" << line << " " << func << ": Checkpoint";
+      if (msg)
+        s << " '" << msg << "'";
+      s << std::endl;
+  }
+};
+
+inline Checkpoint& globalCheckpoint() {
+    static Checkpoint C;
+    return C;
+}
+
+inline void clearCheckpoint() {
+    globalCheckpoint() = Checkpoint();
+}
+
+#if defined(__GNUC__)
+#define CHECKPOINT_FUNCTION_NAME __PRETTY_FUNCTION__
+#else
+#define CHECKPOINT_FUNCTION_NAME __func__
+#endif
+
+#define CHECKPOINT(msg) globalCheckpoint() = Checkpoint(__FILE__, CHECKPOINT_FUNCTION_NAME, __LINE__, msg);
+
+inline void checkpointSignalHandler(int signal) {
+    if (signal == SIGABRT) {
+        globalCheckpoint().print(std::cerr);
+    } else {
+        std::cerr << "Unexpected signal " << signal << " received\n";
+    }
+    std::_Exit(EXIT_FAILURE);
+}
+
+inline bool initCheckpointHandler() {
+    typedef void(*HandlerT)(int);
+    static bool isInit = false;
+    if (isInit) return true;
+    HandlerT prev_h = std::signal(SIGABRT, checkpointSignalHandler);
+    if (prev_h == SIG_ERR) {
+        std::cerr << "Setup failed.\n";
+        std::_Exit(EXIT_FAILURE);
+    }
+    isInit = true;
+    return false;
+}
+
+static bool initDummy = initCheckpointHandler();
+
+#endif
diff --git a/test/support/constexpr_char_traits.hpp b/test/support/constexpr_char_traits.hpp
index b069c90076a2..0a73d3ad1ead 100644
--- a/test/support/constexpr_char_traits.hpp
+++ b/test/support/constexpr_char_traits.hpp
@@ -11,9 +11,9 @@
 #ifndef _CONSTEXPR_CHAR_TRAITS
 #define _CONSTEXPR_CHAR_TRAITS
 
-#include <__config>
 #include <string>
 
+#include "test_macros.h"
 
 template <class _CharT>
 struct constexpr_char_traits
@@ -24,41 +24,41 @@ struct constexpr_char_traits
     typedef std::streampos pos_type;
     typedef std::mbstate_t state_type;
 
-    static _LIBCPP_CONSTEXPR_AFTER_CXX11 void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT
+    static TEST_CONSTEXPR_CXX14 void assign(char_type& __c1, const char_type& __c2) TEST_NOEXCEPT
         {__c1 = __c2;}
 
-    static _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
+    static TEST_CONSTEXPR bool eq(char_type __c1, char_type __c2) TEST_NOEXCEPT
         {return __c1 == __c2;}
 
-    static _LIBCPP_CONSTEXPR  bool lt(char_type __c1, char_type __c2) _NOEXCEPT
+    static TEST_CONSTEXPR  bool lt(char_type __c1, char_type __c2) TEST_NOEXCEPT
         {return __c1 < __c2;}
 
-    static _LIBCPP_CONSTEXPR_AFTER_CXX11 int              compare(const char_type* __s1, const char_type* __s2, size_t __n);
-    static _LIBCPP_CONSTEXPR_AFTER_CXX11 size_t           length(const char_type* __s);
-    static _LIBCPP_CONSTEXPR_AFTER_CXX11 const char_type* find(const char_type* __s, size_t __n, const char_type& __a);
-    static _LIBCPP_CONSTEXPR_AFTER_CXX11 char_type*       move(char_type* __s1, const char_type* __s2, size_t __n);
-    static _LIBCPP_CONSTEXPR_AFTER_CXX11 char_type*       copy(char_type* __s1, const char_type* __s2, size_t __n);
-    static _LIBCPP_CONSTEXPR_AFTER_CXX11 char_type*       assign(char_type* __s, size_t __n, char_type __a);
+    static TEST_CONSTEXPR_CXX14 int              compare(const char_type* __s1, const char_type* __s2, size_t __n);
+    static TEST_CONSTEXPR_CXX14 size_t           length(const char_type* __s);
+    static TEST_CONSTEXPR_CXX14 const char_type* find(const char_type* __s, size_t __n, const char_type& __a);
+    static TEST_CONSTEXPR_CXX14 char_type*       move(char_type* __s1, const char_type* __s2, size_t __n);
+    static TEST_CONSTEXPR_CXX14 char_type*       copy(char_type* __s1, const char_type* __s2, size_t __n);
+    static TEST_CONSTEXPR_CXX14 char_type*       assign(char_type* __s, size_t __n, char_type __a);
 
-    static _LIBCPP_CONSTEXPR int_type  not_eof(int_type __c) _NOEXCEPT
+    static TEST_CONSTEXPR int_type  not_eof(int_type __c) TEST_NOEXCEPT
         {return eq_int_type(__c, eof()) ? ~eof() : __c;}
 
-    static _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT
+    static TEST_CONSTEXPR char_type to_char_type(int_type __c) TEST_NOEXCEPT
         {return char_type(__c);}
 
-    static _LIBCPP_CONSTEXPR int_type  to_int_type(char_type __c) _NOEXCEPT
+    static TEST_CONSTEXPR int_type  to_int_type(char_type __c) TEST_NOEXCEPT
         {return int_type(__c);}
 
-    static _LIBCPP_CONSTEXPR bool      eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
+    static TEST_CONSTEXPR bool      eq_int_type(int_type __c1, int_type __c2) TEST_NOEXCEPT
         {return __c1 == __c2;}
 
-    static _LIBCPP_CONSTEXPR int_type  eof() _NOEXCEPT
+    static TEST_CONSTEXPR int_type  eof() TEST_NOEXCEPT
         {return int_type(EOF);}
 };
 
 
 template <class _CharT>
-_LIBCPP_CONSTEXPR_AFTER_CXX11 int
+TEST_CONSTEXPR_CXX14 int
 constexpr_char_traits<_CharT>::compare(const char_type* __s1, const char_type* __s2, size_t __n)
 {
     for (; __n; --__n, ++__s1, ++__s2)
@@ -72,7 +72,7 @@ constexpr_char_traits<_CharT>::compare(const char_type* __s1, const char_type* _
 }
 
 template <class _CharT>
-_LIBCPP_CONSTEXPR_AFTER_CXX11 size_t
+TEST_CONSTEXPR_CXX14 size_t
 constexpr_char_traits<_CharT>::length(const char_type* __s)
 {
     size_t __len = 0;
@@ -82,7 +82,7 @@ constexpr_char_traits<_CharT>::length(const char_type* __s)
 }
 
 template <class _CharT>
-_LIBCPP_CONSTEXPR_AFTER_CXX11 const _CharT*
+TEST_CONSTEXPR_CXX14 const _CharT*
 constexpr_char_traits<_CharT>::find(const char_type* __s, size_t __n, const char_type& __a)
 {
     for (; __n; --__n)
@@ -95,7 +95,7 @@ constexpr_char_traits<_CharT>::find(const char_type* __s, size_t __n, const char
 }
 
 template <class _CharT>
-_LIBCPP_CONSTEXPR_AFTER_CXX11 _CharT*
+TEST_CONSTEXPR_CXX14 _CharT*
 constexpr_char_traits<_CharT>::move(char_type* __s1, const char_type* __s2, size_t __n)
 {
     char_type* __r = __s1;
@@ -115,7 +115,7 @@ constexpr_char_traits<_CharT>::move(char_type* __s1, const char_type* __s2, size
 }
 
 template <class _CharT>
-_LIBCPP_CONSTEXPR_AFTER_CXX11 _CharT*
+TEST_CONSTEXPR_CXX14 _CharT*
 constexpr_char_traits<_CharT>::copy(char_type* __s1, const char_type* __s2, size_t __n)
 {
     _LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
@@ -126,7 +126,7 @@ constexpr_char_traits<_CharT>::copy(char_type* __s1, const char_type* __s2, size
 }
 
 template <class _CharT>
-_LIBCPP_CONSTEXPR_AFTER_CXX11 _CharT*
+TEST_CONSTEXPR_CXX14 _CharT*
 constexpr_char_traits<_CharT>::assign(char_type* __s, size_t __n, char_type __a)
 {
     char_type* __r = __s;
diff --git a/test/support/container_test_types.h b/test/support/container_test_types.h
new file mode 100644
index 000000000000..0b97f2e94e75
--- /dev/null
+++ b/test/support/container_test_types.h
@@ -0,0 +1,492 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+#ifndef SUPPORT_CONTAINER_TEST_TYPES_H
+#define SUPPORT_CONTAINER_TEST_TYPES_H
+
+// container_test_types.h - A set of types used for testing STL containers.
+// The types container within this header are used to test the requirements in
+// [container.requirements.general]. The header is made up of 3 main components:
+//
+// * test-types: 'CopyInsertable', 'MoveInsertable' and 'EmplaceConstructible' -
+//    These test types are used to test the container requirements of the same
+//    name. These test types use the global 'AllocatorConstructController' to
+//    assert that they are only constructed by the containers allocator.
+//
+// * test-allocator: 'ContainerTestAllocator' - This test allocator is used to
+//    test the portions of [container.requirements.general] that pertain to the
+//    containers allocator. The three primary jobs of the test allocator are:
+//      1. Enforce that 'a.construct(...)' and 'a.destroy(...)' are only ever
+//         instantiated for 'Container::value_type'.
+//      2. Provide a mechanism of checking calls to 'a.construct(Args...)'.
+//         Including controlling when and with what types 'a.construct(...)'
+//         may be called with.
+//      3. Support the test types internals by controlling the global
+//        'AllocatorConstructController' object.
+//
+// * 'AllocatorConstructController' - This type defines an interface for testing
+//   the construction of types using an allocator. This type is used to communicate
+//   between the test author, the containers allocator, and the types
+//   being constructed by the container.
+//   The controllers primary functions are:
+//     1. Allow calls to 'a.construct(p, args...)' to be checked by a test.
+//        The test uses 'cc->expect<Args...>()' to specify that the allocator
+//        should expect one call to 'a.construct' with the specified argument
+//        types.
+//     2. Controlling the value of 'cc->isInAllocatorConstruct()' within the
+//        'construct' method. The test-types use this value to assert that
+//         they are being constructed by the allocator.
+//
+//   'AllocatorConstructController' enforces the Singleton pattern since the
+//    test-types, test-allocator and test need to share the same controller
+//    object. A pointer to the global controller is returned by
+//   'getConstructController()'.
+//
+//----------------------------------------------------------------------------
+/*
+ * Usage: The following example checks that 'unordered_map::emplace(Args&&...)'
+ *        with 'Args = [CopyInsertable<1> const&, CopyInsertible<2>&&]'
+ *        calls 'alloc.construct(value_type*, Args&&...)' with the same types.
+ *
+ * // Typedefs for container
+ * using Key = CopyInsertible<1>;
+ * using Value = CopyInsertible<2>;
+ * using ValueTp = std::pair<const Key, Value>;
+ * using Alloc = ContainerTestAllocator<ValueTp, ValueTp>;
+ * using Map = std::unordered_map<Key, Value, std::hash<Key>, std::equal_to<Key>, Alloc>;
+ *
+ * // Get the global controller, reset it, and construct an allocator with
+ * // the controller.
+ * ConstructController* cc = getConstructController();
+ * cc->reset();
+ *
+ * // Create a Map and a Key and Value to insert. Note that the test-allocator
+ * // does not need to be given 'cc'.
+ * Map m;
+ * const Key k(1);
+ * Value v(1);
+ *
+ * // Tell the controller to expect a construction from the specified types.
+ * cc->expect<Key const&, Value&&>();
+ *
+ * // Emplace the objects into the container. 'Alloc.construct(p, UArgs...)'
+ * // will assert 'cc->check<UArgs&&>()' is true which will consume
+ * // the call to 'cc->expect<...>()'.
+ * m.emplace(k, std::move(v));
+ *
+ * // Assert that the "expect" was consumed by a matching "check" call within
+ * // Alloc.
+ * assert(!cc->unexpected());
+ *
+ */
+
+#include <functional>
+#include <cassert>
+
+#include "test_macros.h"
+
+#if TEST_STD_VER < 11
+#error This header requires C++11 or greater
+#endif
+
+namespace detail {
+// TypeID - Represent a unique identifier for a type. TypeID allows equality
+// comparisons between different types.
+struct TypeID {
+  friend bool operator==(TypeID const& LHS, TypeID const& RHS)
+  {return LHS.m_id == RHS.m_id; }
+  friend bool operator!=(TypeID const& LHS, TypeID const& RHS)
+  {return LHS.m_id != RHS.m_id; }
+private:
+  explicit constexpr TypeID(const int* xid) : m_id(xid) {}
+  const int* const m_id;
+  template <class T> friend class TypeInfo;
+};
+
+// TypeInfo - Represent information for the specified type 'T', including a
+// unique TypeID.
+template <class T>
+class TypeInfo {
+public:
+  typedef T value_type;
+  typedef TypeID ID;
+  static  ID const& GetID() { static ID id(&dummy_addr); return id; }
+
+private:
+  static const int dummy_addr;
+};
+
+template <class L, class R>
+inline bool operator==(TypeInfo<L> const&, TypeInfo<R> const&)
+{ return std::is_same<L, R>::value; }
+
+template <class L, class R>
+inline bool operator!=(TypeInfo<L> const& lhs, TypeInfo<R> const& rhs)
+{ return !(lhs == rhs); }
+
+template <class T>
+const int TypeInfo<T>::dummy_addr = 42;
+
+// makeTypeID - Return the TypeID for the specified type 'T'.
+template <class T>
+inline constexpr TypeID const& makeTypeID() { return TypeInfo<T>::GetID(); }
+
+template <class ...Args>
+struct ArgumentListID {};
+
+// makeArgumentID - Create and return a unique identifier for a given set
+// of arguments.
+template <class ...Args>
+inline constexpr TypeID const& makeArgumentID() {
+  return makeTypeID<ArgumentListID<Args...>>();
+}
+
+} // namespace detail
+
+//===----------------------------------------------------------------------===//
+//                        AllocatorConstructController
+//===----------------------------------------------------------------------===//
+
+struct AllocatorConstructController {
+  const detail::TypeID* m_expected_args;
+  bool m_allow_constructions;
+  bool m_allow_unchecked;
+  int m_expected_count;
+
+  void clear() {
+    m_expected_args = nullptr;
+    m_expected_count = -1;
+  }
+
+  // Check for and consume an expected construction added by 'expect'.
+  // Return true if the construction was expected and false otherwise.
+  // This should only be called by 'Allocator.construct'.
+  bool check(detail::TypeID const& tid) {
+    if (!m_expected_args)
+      assert(m_allow_unchecked);
+    bool res = *m_expected_args == tid;
+    if (m_expected_count == -1 || --m_expected_count == -1)
+      m_expected_args = nullptr;
+    return res;
+  }
+
+  // Return true iff there is an unchecked construction expression.
+  bool unchecked() {
+    return m_expected_args != nullptr;
+  }
+
+  // Expect a call to Allocator::construct with Args that match 'tid'.
+  void expect(detail::TypeID const& tid) {
+    assert(!unchecked());
+    m_expected_args = &tid;
+  }
+
+  template <class ...Args>
+  void expect(int times = 1) {
+    assert(!unchecked());
+    assert(times > 0);
+    m_expected_count = times - 1;
+    m_expected_args = &detail::makeArgumentID<Args...>();
+  }
+  template <class ...Args>
+  bool check() {
+    return check(detail::makeArgumentID<Args...>());
+  }
+
+
+  // Return true iff the program is currently within a call to "Allocator::construct"
+  bool isInAllocatorConstruct() const {
+    return m_allow_constructions;
+  }
+
+  void inAllocatorConstruct(bool value = true) {
+    m_allow_constructions = value;
+  }
+
+  void allowUnchecked(bool value = true) {
+    m_allow_unchecked = value;
+  }
+
+  void reset() {
+    m_allow_constructions = false;
+    m_expected_args = nullptr;
+    m_allow_unchecked = false;
+    m_expected_count = -1;
+  }
+
+private:
+  friend AllocatorConstructController* getConstructController();
+  AllocatorConstructController()  { reset(); }
+  AllocatorConstructController(AllocatorConstructController const&);
+  AllocatorConstructController& operator=(AllocatorConstructController const&);
+};
+
+typedef AllocatorConstructController ConstructController;
+
+// getConstructController - Return the global allocator construction controller.
+inline ConstructController* getConstructController() {
+  static ConstructController c;
+  return &c;
+}
+
+//===----------------------------------------------------------------------===//
+//                       ContainerTestAllocator
+//===----------------------------------------------------------------------===//
+
+// ContainerTestAllocator - A STL allocator type that only allows 'construct'
+// and 'destroy' to be called for 'AllowConstructT' types. ContainerTestAllocator
+// uses the 'AllocatorConstructionController' interface.
+template <class T, class AllowConstructT>
+class ContainerTestAllocator
+{
+  struct InAllocatorConstructGuard {
+    ConstructController *m_cc;
+    bool m_old;
+    InAllocatorConstructGuard(ConstructController* cc) : m_cc(cc) {
+      if (m_cc) {
+        m_old = m_cc->isInAllocatorConstruct();
+        m_cc->inAllocatorConstruct(true);
+      }
+    }
+    ~InAllocatorConstructGuard() {
+      if (m_cc) m_cc->inAllocatorConstruct(m_old);
+    }
+  private:
+    InAllocatorConstructGuard(InAllocatorConstructGuard const&);
+    InAllocatorConstructGuard& operator=(InAllocatorConstructGuard const&);
+  };
+
+public:
+    typedef T value_type;
+
+    int construct_called;
+    int destroy_called;
+    ConstructController* controller;
+
+    ContainerTestAllocator() TEST_NOEXCEPT
+        : controller(getConstructController()) {}
+
+    explicit ContainerTestAllocator(ConstructController* c)
+       : controller(c)
+    {}
+
+    template <class U>
+    ContainerTestAllocator(ContainerTestAllocator<U, AllowConstructT> other) TEST_NOEXCEPT
+      : controller(other.controller)
+    {}
+
+    T* allocate(std::size_t n)
+    {
+        return static_cast<T*>(::operator new(n*sizeof(T)));
+    }
+
+    void deallocate(T* p, std::size_t)
+    {
+        return ::operator delete(static_cast<void*>(p));
+    }
+
+    template <class Up, class ...Args>
+    void construct(Up* p, Args&&... args) {
+      static_assert((std::is_same<Up, AllowConstructT>::value),
+                    "Only allowed to construct Up");
+      assert(controller->check<Args&&...>());
+      {
+        InAllocatorConstructGuard g(controller);
+        ::new ((void*)p) Up(std::forward<Args>(args)...);
+      }
+    }
+
+    template <class Up>
+    void destroy(Up* p) {
+      static_assert((std::is_same<Up, AllowConstructT>::value),
+                    "Only allowed to destroy Up");
+      {
+        InAllocatorConstructGuard g(controller);
+        p->~Up();
+      }
+    }
+
+    friend bool operator==(ContainerTestAllocator, ContainerTestAllocator) {return true;}
+    friend bool operator!=(ContainerTestAllocator x, ContainerTestAllocator y) {return !(x == y);}
+};
+
+
+namespace test_detail {
+typedef ContainerTestAllocator<int, int> A1;
+typedef std::allocator_traits<A1> A1T;
+typedef ContainerTestAllocator<float, int> A2;
+typedef std::allocator_traits<A2> A2T;
+
+static_assert(std::is_same<A1T::rebind_traits<float>, A2T>::value, "");
+static_assert(std::is_same<A2T::rebind_traits<int>, A1T>::value, "");
+} // end namespace test_detail
+
+//===----------------------------------------------------------------------===//
+//  'CopyInsertable', 'MoveInsertable' and 'EmplaceConstructible' test types
+//===----------------------------------------------------------------------===//
+
+template <int Dummy = 0>
+struct CopyInsertable {
+  int data;
+  mutable bool copied_once;
+  bool constructed_under_allocator;
+
+  explicit CopyInsertable(int val) : data(val), copied_once(false),
+                                     constructed_under_allocator(false) {
+    if (getConstructController()->isInAllocatorConstruct()) {
+      copied_once = true;
+      constructed_under_allocator = true;
+    }
+  }
+
+  CopyInsertable() : data(0), copied_once(false), constructed_under_allocator(true)
+  {
+    assert(getConstructController()->isInAllocatorConstruct());
+  }
+
+  CopyInsertable(CopyInsertable const& other) : data(other.data),
+                                                copied_once(true),
+                                                constructed_under_allocator(true) {
+    assert(getConstructController()->isInAllocatorConstruct());
+    assert(other.copied_once == false);
+    other.copied_once = true;
+  }
+
+  CopyInsertable(CopyInsertable& other) : data(other.data), copied_once(true),
+                                          constructed_under_allocator(true) {
+    assert(getConstructController()->isInAllocatorConstruct());
+    assert(other.copied_once == false);
+    other.copied_once = true;
+  }
+
+  CopyInsertable(CopyInsertable&& other) : CopyInsertable(other) {}
+
+  // Forgive pair for not downcasting this to an lvalue it its constructors.
+  CopyInsertable(CopyInsertable const && other) : CopyInsertable(other) {}
+
+
+  template <class ...Args>
+  CopyInsertable(Args&&... args) {
+    assert(false);
+  }
+
+  ~CopyInsertable() {
+    assert(constructed_under_allocator == getConstructController()->isInAllocatorConstruct());
+  }
+
+  void reset(int value) {
+    data = value;
+    copied_once = false;
+    constructed_under_allocator = false;
+  }
+};
+
+template <int ID>
+bool operator==(CopyInsertable<ID> const& L, CopyInsertable<ID> const& R) {
+  return L.data == R.data;
+}
+
+
+template <int ID>
+bool operator!=(CopyInsertable<ID> const& L, CopyInsertable<ID> const& R) {
+  return L.data != R.data;
+}
+
+template <int ID>
+bool operator <(CopyInsertable<ID> const& L, CopyInsertable<ID> const& R) {
+  return L.data < R.data;
+}
+
+
+#ifdef _LIBCPP_BEGIN_NAMESPACE_STD
+_LIBCPP_BEGIN_NAMESPACE_STD
+#else
+namespace std {
+#endif
+  template <int ID>
+  struct hash< ::CopyInsertable<ID> > {
+    typedef ::CopyInsertable<ID> argument_type;
+    typedef size_t result_type;
+
+    size_t operator()(argument_type const& arg) const {
+      return arg.data;
+    }
+  };
+
+  template <class _Key, class _Value, class _Less, class _Alloc>
+  class map;
+  template <class _Key, class _Value, class _Less, class _Alloc>
+  class multimap;
+  template <class _Value, class _Less, class _Alloc>
+  class set;
+  template <class _Value, class _Less, class _Alloc>
+  class multiset;
+  template <class _Key, class _Value, class _Hash, class _Equals, class _Alloc>
+  class unordered_map;
+  template <class _Key, class _Value, class _Hash, class _Equals, class _Alloc>
+  class unordered_multimap;
+  template <class _Value, class _Hash, class _Equals, class _Alloc>
+  class unordered_set;
+  template <class _Value, class _Hash, class _Equals, class _Alloc>
+  class unordered_multiset;
+
+#ifdef _LIBCPP_END_NAMESPACE_STD
+_LIBCPP_END_NAMESPACE_STD
+#else
+} // end namespace std
+#endif
+
+// TCT - Test container type
+namespace TCT {
+
+template <class Key = CopyInsertable<1>, class Value = CopyInsertable<2>,
+          class ValueTp = std::pair<const Key, Value> >
+using unordered_map =
+      std::unordered_map<Key, Value, std::hash<Key>, std::equal_to<Key>,
+                              ContainerTestAllocator<ValueTp, ValueTp> >;
+
+template <class Key = CopyInsertable<1>, class Value = CopyInsertable<2>,
+          class ValueTp = std::pair<const Key, Value> >
+using map =
+      std::map<Key, Value, std::less<Key>,
+                              ContainerTestAllocator<ValueTp, ValueTp> >;
+
+template <class Key = CopyInsertable<1>, class Value = CopyInsertable<2>,
+          class ValueTp = std::pair<const Key, Value> >
+using unordered_multimap =
+      std::unordered_multimap<Key, Value, std::hash<Key>, std::equal_to<Key>,
+                                   ContainerTestAllocator<ValueTp, ValueTp> >;
+
+template <class Key = CopyInsertable<1>, class Value = CopyInsertable<2>,
+          class ValueTp = std::pair<const Key, Value> >
+using multimap =
+      std::multimap<Key, Value, std::less<Key>,
+                              ContainerTestAllocator<ValueTp, ValueTp> >;
+
+template <class Value = CopyInsertable<1> >
+using unordered_set =
+  std::unordered_set<Value, std::hash<Value>, std::equal_to<Value>,
+                               ContainerTestAllocator<Value, Value> >;
+
+template <class Value = CopyInsertable<1> >
+using set =
+    std::set<Value, std::less<Value>, ContainerTestAllocator<Value, Value> >;
+
+template <class Value = CopyInsertable<1> >
+using unordered_multiset =
+    std::unordered_multiset<Value, std::hash<Value>, std::equal_to<Value>,
+                                    ContainerTestAllocator<Value, Value> >;
+
+template <class Value = CopyInsertable<1> >
+using multiset =
+    std::multiset<Value, std::less<Value>, ContainerTestAllocator<Value, Value> >;
+
+} // end namespace TCT
+
+
+#endif // SUPPORT_CONTAINER_TEST_TYPES_H
diff --git a/test/support/count_new.hpp b/test/support/count_new.hpp
index e8968a93de98..923e49513487 100644
--- a/test/support/count_new.hpp
+++ b/test/support/count_new.hpp
@@ -14,16 +14,24 @@
 # include <cassert>
 # include <new>
 
-#ifndef __has_feature
-#  define __has_feature(x) 0
-#endif
+#include "test_macros.h"
 
-#if  __has_feature(address_sanitizer) \
-  || __has_feature(memory_sanitizer) \
-  || __has_feature(thread_sanitizer)
+#if defined(TEST_HAS_SANITIZERS)
 #define DISABLE_NEW_COUNT
 #endif
 
+namespace detail
+{
+   TEST_NORETURN
+   inline void throw_bad_alloc_helper() {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+       throw std::bad_alloc();
+#else
+       std::abort();
+#endif
+   }
+}
+
 class MemCounter
 {
 public:
@@ -43,6 +51,11 @@ public:
     // code doesn't perform any allocations.
     bool disable_allocations;
 
+    // number of allocations to throw after. Default (unsigned)-1. If
+    // throw_after has the default value it will never be decremented.
+    static const unsigned never_throw_value = static_cast<unsigned>(-1);
+    unsigned throw_after;
+
     int outstanding_new;
     int new_called;
     int delete_called;
@@ -58,6 +71,12 @@ public:
     {
         assert(disable_allocations == false);
         assert(s);
+        if (throw_after == 0) {
+            throw_after = never_throw_value;
+            detail::throw_bad_alloc_helper();
+        } else if (throw_after != never_throw_value) {
+            --throw_after;
+        }
         ++new_called;
         ++outstanding_new;
         last_new_size = s;
@@ -74,6 +93,12 @@ public:
     {
         assert(disable_allocations == false);
         assert(s);
+        if (throw_after == 0) {
+            throw_after = never_throw_value;
+            detail::throw_bad_alloc_helper();
+        } else {
+            // don't decrement throw_after here. newCalled will end up doing that.
+        }
         ++outstanding_array_new;
         ++new_array_called;
         last_new_array_size = s;
@@ -96,9 +121,11 @@ public:
         disable_allocations = false;
     }
 
+
     void reset()
     {
         disable_allocations = false;
+        throw_after = never_throw_value;
 
         outstanding_new = 0;
         new_called = 0;
@@ -132,6 +159,11 @@ public:
         return disable_checking || n != new_called;
     }
 
+    bool checkNewCalledGreaterThan(int n) const
+    {
+        return disable_checking || new_called > n;
+    }
+
     bool checkDeleteCalledEq(int n) const
     {
         return disable_checking || n == delete_called;
@@ -205,7 +237,10 @@ MemCounter globalMemCounter((MemCounter::MemCounterCtorArg_()));
 void* operator new(std::size_t s) throw(std::bad_alloc)
 {
     globalMemCounter.newCalled(s);
-    return std::malloc(s);
+    void* ret = std::malloc(s);
+    if (ret == nullptr)
+        detail::throw_bad_alloc_helper();
+    return ret;
 }
 
 void  operator delete(void* p) throw()
@@ -255,4 +290,33 @@ private:
     DisableAllocationGuard& operator=(DisableAllocationGuard const&);
 };
 
+
+struct RequireAllocationGuard {
+    explicit RequireAllocationGuard(std::size_t RequireAtLeast = 1)
+            : m_req_alloc(RequireAtLeast),
+              m_new_count_on_init(globalMemCounter.new_called),
+              m_outstanding_new_on_init(globalMemCounter.outstanding_new),
+              m_exactly(false)
+    {
+    }
+
+    void requireAtLeast(std::size_t N) { m_req_alloc = N; m_exactly = false; }
+    void requireExactly(std::size_t N) { m_req_alloc = N; m_exactly = true; }
+
+    ~RequireAllocationGuard() {
+        assert(globalMemCounter.checkOutstandingNewEq(m_outstanding_new_on_init));
+        std::size_t Expect = m_new_count_on_init + m_req_alloc;
+        assert(globalMemCounter.checkNewCalledEq(Expect) ||
+               (!m_exactly && globalMemCounter.checkNewCalledGreaterThan(Expect)));
+    }
+
+private:
+    std::size_t m_req_alloc;
+    const std::size_t m_new_count_on_init;
+    const std::size_t m_outstanding_new_on_init;
+    bool m_exactly;
+    RequireAllocationGuard(RequireAllocationGuard const&);
+    RequireAllocationGuard& operator=(RequireAllocationGuard const&);
+};
+
 #endif /* COUNT_NEW_HPP */
diff --git a/test/support/counting_predicates.hpp b/test/support/counting_predicates.hpp
index aab6a9785772..2bd1426934e5 100644
--- a/test/support/counting_predicates.hpp
+++ b/test/support/counting_predicates.hpp
@@ -16,11 +16,11 @@ struct unary_counting_predicate : public std::unary_function<Arg, bool>  {
 public:
     unary_counting_predicate(Predicate p) : p_(p), count_(0) {}
     ~unary_counting_predicate() {}
-    
+
     bool operator () (const Arg &a) const { ++count_; return p_(a); }
     size_t count() const { return count_; }
     void reset() { count_ = 0; }
-    
+
 private:
     Predicate p_;
     mutable size_t count_;
@@ -33,7 +33,7 @@ public:
 
     binary_counting_predicate ( Predicate p ) : p_(p), count_(0) {}
     ~binary_counting_predicate() {}
-    
+
     bool operator () (const Arg1 &a1, const Arg2 &a2) const { ++count_; return p_(a1, a2); }
     size_t count() const { return count_; }
     void reset() { count_ = 0; }
diff --git a/test/support/disable_missing_braces_warning.h b/test/support/disable_missing_braces_warning.h
index 97fd8a89a51a..c53eef8a951d 100644
--- a/test/support/disable_missing_braces_warning.h
+++ b/test/support/disable_missing_braces_warning.h
@@ -11,6 +11,8 @@
 
 // std::array is explicitly allowed to be initialized with A a = { init-list };.
 // Disable the missing braces warning for this reason.
+#if defined(__GNUC__)
 #pragma GCC diagnostic ignored "-Wmissing-braces"
+#endif
 
 #endif // SUPPORT_DISABLE_MISSING_BRACES_WARNING_H
diff --git a/test/support/filesystem_dynamic_test_helper.py b/test/support/filesystem_dynamic_test_helper.py
new file mode 100644
index 000000000000..1f48c9527982
--- /dev/null
+++ b/test/support/filesystem_dynamic_test_helper.py
@@ -0,0 +1,85 @@
+import sys
+import os
+import stat
+
+# Ensure that this is being run on a specific platform
+assert sys.platform.startswith('linux') or sys.platform.startswith('darwin') \
+    or sys.platform.startswith('cygwin') or sys.platform.startswith('freebsd')
+
+def env_path():
+    ep = os.environ.get('LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT')
+    assert ep is not None
+    ep = os.path.realpath(ep)
+    assert os.path.isdir(ep)
+    return ep
+
+env_path_global = env_path()
+
+# Make sure we don't try and write outside of env_path.
+# All paths used should be sanitized
+def sanitize(p):
+    p = os.path.realpath(p)
+    if os.path.commonprefix([env_path_global, p]):
+        return p
+    assert False
+
+"""
+Some of the tests restrict permissions to induce failures.
+Before we delete the test enviroment, we have to walk it and re-raise the
+permissions.
+"""
+def clean_recursive(root_p):
+    if not os.path.islink(root_p):
+        os.chmod(root_p, 0o777)
+    for ent in os.listdir(root_p):
+        p = os.path.join(root_p, ent)
+        if os.path.islink(p) or not os.path.isdir(p):
+            os.remove(p)
+        else:
+            assert os.path.isdir(p)
+            clean_recursive(p)
+            os.rmdir(p)
+
+
+def init_test_directory(root_p):
+    root_p = sanitize(root_p)
+    assert not os.path.exists(root_p)
+    os.makedirs(root_p)
+
+
+def destroy_test_directory(root_p):
+    root_p = sanitize(root_p)
+    clean_recursive(root_p)
+    os.rmdir(root_p)
+
+
+def create_file(fname, size):
+    with open(sanitize(fname), 'w') as f:
+        f.write('c' * size)
+
+
+def create_dir(dname):
+    os.mkdir(sanitize(dname))
+
+
+def create_symlink(source, link):
+    os.symlink(sanitize(source), sanitize(link))
+
+
+def create_hardlink(source, link):
+    os.link(sanitize(source), sanitize(link))
+
+
+def create_fifo(source):
+    os.mkfifo(sanitize(source))
+
+
+def create_socket(source):
+    mode = 0600|stat.S_IFSOCK
+    os.mknod(sanitize(source), mode)
+
+
+if __name__ == '__main__':
+    command = " ".join(sys.argv[1:])
+    eval(command)
+    sys.exit(0)
diff --git a/test/support/filesystem_test_helper.hpp b/test/support/filesystem_test_helper.hpp
new file mode 100644
index 000000000000..7150f79739b6
--- /dev/null
+++ b/test/support/filesystem_test_helper.hpp
@@ -0,0 +1,403 @@
+#ifndef FILESYSTEM_TEST_HELPER_HPP
+#define FILESYSTEM_TEST_HELPER_HPP
+
+#include <experimental/filesystem>
+#include <cassert>
+#include <cstdio> // for printf
+#include <string>
+#include <fstream>
+#include <random>
+#include <chrono>
+
+namespace fs = std::experimental::filesystem;
+
+// static test helpers
+
+#ifndef LIBCXX_FILESYSTEM_STATIC_TEST_ROOT
+#warning "STATIC TESTS DISABLED"
+#else // LIBCXX_FILESYSTEM_STATIC_TEST_ROOT
+
+namespace StaticEnv {
+
+inline fs::path makePath(fs::path const& p) {
+    // env_path is expected not to contain symlinks.
+    static const fs::path env_path = LIBCXX_FILESYSTEM_STATIC_TEST_ROOT;
+    return env_path / p;
+}
+
+static const fs::path Root = LIBCXX_FILESYSTEM_STATIC_TEST_ROOT;
+
+static const fs::path TestFileList[] = {
+        makePath("empty_file"),
+        makePath("non_empty_file"),
+        makePath("dir1/file1"),
+        makePath("dir1/file2")
+};
+const std::size_t TestFileListSize = sizeof(TestFileList) / sizeof(fs::path);
+
+static const fs::path TestDirList[] = {
+        makePath("dir1"),
+        makePath("dir1/dir2"),
+        makePath("dir1/dir2/dir3")
+};
+const std::size_t TestDirListSize = sizeof(TestDirList) / sizeof(fs::path);
+
+static const fs::path File          = TestFileList[0];
+static const fs::path Dir           = TestDirList[0];
+static const fs::path Dir2          = TestDirList[1];
+static const fs::path Dir3          = TestDirList[2];
+static const fs::path SymlinkToFile = makePath("symlink_to_empty_file");
+static const fs::path SymlinkToDir  = makePath("symlink_to_dir");
+static const fs::path BadSymlink    = makePath("bad_symlink");
+static const fs::path DNE           = makePath("DNE");
+static const fs::path EmptyFile     = TestFileList[0];
+static const fs::path NonEmptyFile  = TestFileList[1];
+static const fs::path CharFile      = "/dev/null"; // Hopefully this exists
+
+static const fs::path DirIterationList[] = {
+    makePath("dir1/dir2"),
+    makePath("dir1/file1"),
+    makePath("dir1/file2")
+};
+const std::size_t DirIterationListSize = sizeof(DirIterationList)
+                                        / sizeof(fs::path);
+
+static const fs::path DirIterationListDepth1[] = {
+    makePath("dir1/dir2/afile3"),
+    makePath("dir1/dir2/dir3"),
+    makePath("dir1/dir2/symlink_to_dir3"),
+    makePath("dir1/dir2/file4"),
+};
+
+static const fs::path RecDirIterationList[] = {
+    makePath("dir1/dir2"),
+    makePath("dir1/file1"),
+    makePath("dir1/file2"),
+    makePath("dir1/dir2/afile3"),
+    makePath("dir1/dir2/dir3"),
+    makePath("dir1/dir2/symlink_to_dir3"),
+    makePath("dir1/dir2/file4"),
+    makePath("dir1/dir2/dir3/file5")
+};
+
+static const fs::path RecDirFollowSymlinksIterationList[] = {
+    makePath("dir1/dir2"),
+    makePath("dir1/file1"),
+    makePath("dir1/file2"),
+    makePath("dir1/dir2/afile3"),
+    makePath("dir1/dir2/dir3"),
+    makePath("dir1/dir2/file4"),
+    makePath("dir1/dir2/dir3/file5"),
+    makePath("dir1/dir2/symlink_to_dir3"),
+    makePath("dir1/dir2/symlink_to_dir3/file5"),
+};
+
+} // namespace StaticEnv
+
+#endif // LIBCXX_FILESYSTEM_STATIC_TEST_ROOT
+
+#ifndef LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT
+#warning LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT must be defined
+#else // LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT
+
+#ifndef LIBCXX_FILESYSTEM_DYNAMIC_TEST_HELPER
+#error LIBCXX_FILESYSTEM_DYNAMIC_TEST_HELPER must be defined
+#endif
+
+struct scoped_test_env
+{
+    scoped_test_env() : test_root(random_env_path())
+        { fs_helper_run(fs_make_cmd("init_test_directory", test_root)); }
+
+    ~scoped_test_env()
+        { fs_helper_run(fs_make_cmd("destroy_test_directory", test_root)); }
+
+    scoped_test_env(scoped_test_env const &) = delete;
+    scoped_test_env & operator=(scoped_test_env const &) = delete;
+
+    fs::path make_env_path(std::string p) { return sanitize_path(p); }
+
+    std::string sanitize_path(std::string raw) {
+        assert(raw.find("..") == std::string::npos);
+        std::string const& root = test_root.native();
+        if (root.compare(0, root.size(), raw, 0, root.size()) != 0) {
+            assert(raw.front() != '\\');
+            fs::path tmp(test_root);
+            tmp /= raw;
+            return std::move(const_cast<std::string&>(tmp.native()));
+        }
+        return raw;
+    }
+
+    std::string create_file(std::string filename, std::size_t size = 0) {
+        filename = sanitize_path(std::move(filename));
+        std::string out_str(size, 'a');
+        {
+            std::ofstream out(filename.c_str());
+            out << out_str;
+        }
+        return filename;
+    }
+
+    std::string create_dir(std::string filename) {
+        filename = sanitize_path(std::move(filename));
+        fs_helper_run(fs_make_cmd("create_dir", filename));
+        return filename;
+    }
+
+    std::string create_symlink(std::string source, std::string to) {
+        source = sanitize_path(std::move(source));
+        to = sanitize_path(std::move(to));
+        fs_helper_run(fs_make_cmd("create_symlink", source, to));
+        return to;
+    }
+
+    std::string create_hardlink(std::string source, std::string to) {
+        source = sanitize_path(std::move(source));
+        to = sanitize_path(std::move(to));
+        fs_helper_run(fs_make_cmd("create_hardlink", source, to));
+        return to;
+    }
+
+    std::string create_fifo(std::string file) {
+        file = sanitize_path(std::move(file));
+        fs_helper_run(fs_make_cmd("create_fifo", file));
+        return file;
+    }
+
+  // OS X and FreeBSD doesn't support socket files so we shouldn't even
+  // allow tests to call this unguarded.
+#if !defined(__FreeBSD__) && !defined(__APPLE__)
+    std::string create_socket(std::string file) {
+        file = sanitize_path(std::move(file));
+        fs_helper_run(fs_make_cmd("create_socket", file));
+        return file;
+    }
+#endif
+
+    fs::path const test_root;
+
+private:
+    static char to_hex(int ch) {
+        return ch < 10 ? static_cast<char>('0' + ch)
+                       : static_cast<char>('a' + (ch - 10));
+    }
+
+    static char random_hex_char() {
+        static std::mt19937 rd { std::random_device{}() };
+        static std::uniform_int_distribution<int> mrand{0, 15};
+        return to_hex( mrand(rd) );
+    }
+
+    static std::string unique_path_suffix() {
+        std::string model = "test.%%%%%%";
+        for (auto & ch :  model) {
+            if (ch == '%') ch = random_hex_char();
+        }
+        return model;
+    }
+
+    // This could potentially introduce a filesystem race with other tests
+    // running at the same time, but oh well, it's just test code.
+    static inline fs::path random_env_path() {
+        static const char* env_path = LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT;
+        fs::path p = fs::path(env_path) / unique_path_suffix();
+        assert(p.parent_path() == env_path);
+        return p;
+    }
+
+    static inline std::string make_arg(std::string const& arg) {
+        return "'" + arg + "'";
+    }
+
+    static inline std::string make_arg(std::size_t arg) {
+        return std::to_string(arg);
+    }
+
+    template <class T>
+    static inline std::string
+    fs_make_cmd(std::string const& cmd_name, T const& arg) {
+        return cmd_name + "(" + make_arg(arg) + ")";
+    }
+
+    template <class T, class U>
+    static inline std::string
+    fs_make_cmd(std::string const& cmd_name, T const& arg1, U const& arg2) {
+        return cmd_name + "(" + make_arg(arg1) + ", " + make_arg(arg2) + ")";
+    }
+
+    static inline void fs_helper_run(std::string const& raw_cmd) {
+        // check that the fs test root in the enviroment matches what we were
+        // compiled with.
+        static bool checked = checkDynamicTestRoot();
+        std::string cmd = LIBCXX_FILESYSTEM_DYNAMIC_TEST_HELPER;
+        cmd += " \"" + raw_cmd + "\"";
+        int ret = std::system(cmd.c_str());
+        assert(ret == 0);
+    }
+
+    static bool checkDynamicTestRoot() {
+        // LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT is expected not to contain symlinks.
+        char* fs_root = std::getenv("LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT");
+        if (!fs_root) {
+            std::printf("ERROR: LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT must be a defined "
+                         "environment variable when running the test.\n");
+            std::abort();
+        }
+        if (std::string(fs_root) != LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT) {
+            std::printf("ERROR: LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT enviroment variable"
+                        " must have the same value as when the test was compiled.\n");
+            std::printf("   Current Value:  '%s'\n", fs_root);
+            std::printf("   Expected Value: '%s'\n", LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT);
+            std::abort();
+        }
+        return true;
+    }
+
+};
+
+#endif // LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT
+
+// Misc test types
+
+#define CONCAT2(LHS, RHS) LHS##RHS
+#define CONCAT(LHS, RHS) CONCAT2(LHS, RHS)
+#define MKSTR(Str) {Str, CONCAT(L, Str), CONCAT(u, Str), CONCAT(U, Str)}
+
+struct MultiStringType {
+  const char* s;
+  const wchar_t* w;
+  const char16_t* u16;
+  const char32_t* u32;
+
+  operator const char* () const { return s; }
+  operator const wchar_t* () const { return w; }
+  operator const char16_t* () const { return u16; }
+  operator const char32_t* () const { return u32; }
+};
+
+const MultiStringType PathList[] = {
+        MKSTR(""),
+        MKSTR(" "),
+        MKSTR("//"),
+        MKSTR("."),
+        MKSTR(".."),
+        MKSTR("foo"),
+        MKSTR("/"),
+        MKSTR("/foo"),
+        MKSTR("foo/"),
+        MKSTR("/foo/"),
+        MKSTR("foo/bar"),
+        MKSTR("/foo/bar"),
+        MKSTR("//net"),
+        MKSTR("//net/foo"),
+        MKSTR("///foo///"),
+        MKSTR("///foo///bar"),
+        MKSTR("/."),
+        MKSTR("./"),
+        MKSTR("/.."),
+        MKSTR("../"),
+        MKSTR("foo/."),
+        MKSTR("foo/.."),
+        MKSTR("foo/./"),
+        MKSTR("foo/./bar"),
+        MKSTR("foo/../"),
+        MKSTR("foo/../bar"),
+        MKSTR("c:"),
+        MKSTR("c:/"),
+        MKSTR("c:foo"),
+        MKSTR("c:/foo"),
+        MKSTR("c:foo/"),
+        MKSTR("c:/foo/"),
+        MKSTR("c:/foo/bar"),
+        MKSTR("prn:"),
+        MKSTR("c:\\"),
+        MKSTR("c:\\foo"),
+        MKSTR("c:foo\\"),
+        MKSTR("c:\\foo\\"),
+        MKSTR("c:\\foo/"),
+        MKSTR("c:/foo\\bar"),
+        MKSTR("//"),
+        MKSTR("/finally/we/need/one/really/really/really/really/really/really/really/long/string")
+};
+const unsigned PathListSize = sizeof(PathList) / sizeof(MultiStringType);
+
+template <class Iter>
+Iter IterEnd(Iter B) {
+  using VT = typename std::iterator_traits<Iter>::value_type;
+  for (; *B != VT{}; ++B)
+    ;
+  return B;
+}
+
+template <class CharT>
+const CharT* StrEnd(CharT const* P) {
+    return IterEnd(P);
+}
+
+template <class CharT>
+std::size_t StrLen(CharT const* P) {
+    return StrEnd(P) - P;
+}
+
+// Testing the allocation behavior of the code_cvt functions requires
+// *knowing* that the allocation was not done by "path::__str_".
+// This hack forces path to allocate enough memory.
+inline void PathReserve(fs::path& p, std::size_t N) {
+  auto const& native_ref = p.native();
+  const_cast<std::string&>(native_ref).reserve(N);
+}
+
+template <class Iter1, class Iter2>
+bool checkCollectionsEqual(
+    Iter1 start1, Iter1 const end1
+  , Iter2 start2, Iter2 const end2
+  )
+{
+    while (start1 != end1 && start2 != end2) {
+        if (*start1 != *start2) {
+            return false;
+        }
+        ++start1; ++start2;
+    }
+    return (start1 == end1 && start2 == end2);
+}
+
+
+template <class Iter1, class Iter2>
+bool checkCollectionsEqualBackwards(
+    Iter1 const start1, Iter1 end1
+  , Iter2 const start2, Iter2 end2
+  )
+{
+    while (start1 != end1 && start2 != end2) {
+        --end1; --end2;
+        if (*end1 != *end2) {
+            return false;
+        }
+    }
+    return (start1 == end1 && start2 == end2);
+}
+
+// We often need to test that the error_code was cleared if no error occurs
+// this function returns a error_code which is set to an error that will
+// never be returned by the filesystem functions.
+inline std::error_code GetTestEC() {
+    return std::make_error_code(std::errc::address_family_not_supported);
+}
+
+// Provide our own Sleep routine since std::this_thread::sleep_for is not
+// available in single-threaded mode.
+void SleepFor(std::chrono::seconds dur) {
+    using namespace std::chrono;
+#if defined(_LIBCPP_HAS_NO_MONOTONIC_CLOCK)
+    using Clock = system_clock;
+#else
+    using Clock = steady_clock;
+#endif
+    const auto wake_time = Clock::now() + dur;
+    while (Clock::now() < wake_time)
+        ;
+}
+
+#endif /* FILESYSTEM_TEST_HELPER_HPP */
diff --git a/test/support/hexfloat.h b/test/support/hexfloat.h
index 7ef093714fed..19008d1d54ab 100644
--- a/test/support/hexfloat.h
+++ b/test/support/hexfloat.h
@@ -15,7 +15,6 @@
 #ifndef HEXFLOAT_H
 #define HEXFLOAT_H
 
-#include <algorithm>
 #include <cmath>
 #include <climits>
 
@@ -23,13 +22,26 @@ template <class T>
 class hexfloat
 {
     T value_;
+
+    static int CountLeadingZeros(unsigned long long n) {
+        const std::size_t Digits = sizeof(unsigned long long) * CHAR_BIT;
+        const unsigned long long TopBit = 1ull << (Digits - 1);
+        if (n == 0) return Digits;
+        int LeadingZeros = 0;
+        while ((n & TopBit) == 0) {
+            ++LeadingZeros;
+            n <<= 1;
+        }
+        return LeadingZeros;
+    }
+
 public:
     hexfloat(long long m1, unsigned long long m0, int exp)
     {
-        const std::size_t n = sizeof(unsigned long long) * CHAR_BIT;
+        const std::size_t Digits = sizeof(unsigned long long) * CHAR_BIT;
         int s = m1 < 0 ? -1 : 1;
-        value_ = std::ldexp(m1 + s * std::ldexp(T(m0), -static_cast<int>(n -
-                                                     std::__clz(m0)/4*4)), exp);
+        int exp2 = -static_cast<int>(Digits - CountLeadingZeros(m0)/4*4);
+        value_ = std::ldexp(m1 + s * std::ldexp(T(m0), exp2), exp);
     }
 
     operator T() const {return value_;}
diff --git a/test/support/is_transparent.h b/test/support/is_transparent.h
index 58255248abc9..d76b00536b52 100644
--- a/test/support/is_transparent.h
+++ b/test/support/is_transparent.h
@@ -10,7 +10,7 @@
 #ifndef TRANSPARENT_H
 #define TRANSPARENT_H
 
-// testing transparent 
+// testing transparent
 #if _LIBCPP_STD_VER > 11
 
 struct transparent_less
@@ -63,7 +63,7 @@ struct C2Int { // comparable to int
 private:
     int i_;
     };
-    
+
 bool operator <(int          rhs,   const C2Int& lhs) { return rhs       < lhs.get(); }
 bool operator <(const C2Int& rhs,   const C2Int& lhs) { return rhs.get() < lhs.get(); }
 bool operator <(const C2Int& rhs,            int lhs) { return rhs.get() < lhs; }
diff --git a/test/support/min_allocator.h b/test/support/min_allocator.h
index 5e3ae5d2a136..701159e0481a 100644
--- a/test/support/min_allocator.h
+++ b/test/support/min_allocator.h
@@ -11,6 +11,9 @@
 #define MIN_ALLOCATOR_H
 
 #include <cstddef>
+#include <cstdlib>
+#include <cstddef>
+#include <cassert>
 
 #include "test_macros.h"
 
@@ -39,8 +42,59 @@ public:
     friend bool operator!=(bare_allocator x, bare_allocator y) {return !(x == y);}
 };
 
+struct malloc_allocator_base {
+    static size_t alloc_count;
+    static size_t dealloc_count;
+    static bool disable_default_constructor;
+
+    static size_t outstanding_alloc() {
+      assert(alloc_count >= dealloc_count);
+      return (alloc_count - dealloc_count);
+    }
+
+    static void reset() {
+        assert(outstanding_alloc() == 0);
+        disable_default_constructor = false;
+        alloc_count = 0;
+        dealloc_count = 0;
+    }
+};
+
+
+size_t malloc_allocator_base::alloc_count = 0;
+size_t malloc_allocator_base::dealloc_count = 0;
+bool malloc_allocator_base::disable_default_constructor = false;
+
+
+template <class T>
+class malloc_allocator : public malloc_allocator_base
+{
+public:
+    typedef T value_type;
+
+    malloc_allocator() TEST_NOEXCEPT { assert(!disable_default_constructor); }
+
+    template <class U>
+    malloc_allocator(malloc_allocator<U>) TEST_NOEXCEPT {}
+
+    T* allocate(std::size_t n)
+    {
+        ++alloc_count;
+        return static_cast<T*>(std::malloc(n*sizeof(T)));
+    }
+
+    void deallocate(T* p, std::size_t)
+    {
+        ++dealloc_count;
+        std::free(static_cast<void*>(p));
+    }
+
+    friend bool operator==(malloc_allocator, malloc_allocator) {return true;}
+    friend bool operator!=(malloc_allocator x, malloc_allocator y) {return !(x == y);}
+};
+
 
-#if __cplusplus >= 201103L
+#if TEST_STD_VER >= 11
 
 #include <memory>
 
@@ -286,6 +340,6 @@ public:
     friend bool operator!=(min_allocator x, min_allocator y) {return !(x == y);}
 };
 
-#endif  // __cplusplus >= 201103L
+#endif  // TEST_STD_VER >= 11
 
 #endif  // MIN_ALLOCATOR_H
diff --git a/test/support/nasty_containers.hpp b/test/support/nasty_containers.hpp
index 5a2e19505424..b571469227d4 100644
--- a/test/support/nasty_containers.hpp
+++ b/test/support/nasty_containers.hpp
@@ -7,9 +7,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef NASTY_VECTOR_H
-#define NASTY_VECTOR_H
+#ifndef NASTY_CONTAINERS_H
+#define NASTY_CONTAINERS_H
 
+#include <cassert>
 #include <vector>
 #include <list>
 
@@ -99,7 +100,7 @@ public:
     { return v_.emplace(pos, std::forward<Args>(args)...); }
 #endif
 #endif
-    
+
     iterator insert(const_iterator pos, const value_type& x) { return v_.insert(pos, x); }
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     iterator insert(const_iterator pos, value_type&& x)      { return v_.insert(pos, std::forward<value_type>(x)); }
@@ -123,10 +124,10 @@ public:
 
     void swap(nasty_vector &nv) _NOEXCEPT_(std::__is_nothrow_swappable<nested_container>::value)
     { v_.swap(nv.v_); }
-    
-    nasty_vector *operator &()             { return nullptr; }  // nasty
-    const nasty_vector *operator &() const { return nullptr; }  // nasty
-    
+
+    nasty_vector *operator &()             { assert(false); return nullptr; }  // nasty
+    const nasty_vector *operator &() const { assert(false); return nullptr; }  // nasty
+
     nested_container v_;
 };
 
@@ -220,7 +221,7 @@ public:
     { return l_.emplace(pos, std::forward<Args>(args)...); }
 #endif
 #endif
-    
+
     iterator insert(const_iterator pos, const value_type& x) { return l_.insert(pos, x); }
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     iterator insert(const_iterator pos, value_type&& x)      { return l_.insert(pos, std::forward<value_type>(x)); }
@@ -242,7 +243,7 @@ public:
 
     void swap(nasty_list &nl) _NOEXCEPT_(std::__is_nothrow_swappable<nested_container>::value)
     { l_.swap(nl.l_); }
-    
+
     void clear() _NOEXCEPT { l_.clear(); }
 
 //     void splice(const_iterator position, list& x);
@@ -253,7 +254,7 @@ public:
 //                                                   const_iterator last);
 //     void splice(const_iterator position, list&& x, const_iterator first,
 //                                                   const_iterator last);
-// 
+//
 //     void remove(const value_type& value);
 //     template <class Pred> void remove_if(Pred pred);
 //     void unique();
@@ -270,8 +271,8 @@ public:
 //         void sort(Compare comp);
 //     void reverse() noexcept;
 
-    nasty_list *operator &()             { return nullptr; }  // nasty
-    const nasty_list *operator &() const { return nullptr; }  // nasty
+    nasty_list *operator &()             { assert(false); return nullptr; }  // nasty
+    const nasty_list *operator &() const { assert(false); return nullptr; }  // nasty
 
     nested_container l_;
 };
@@ -279,4 +280,30 @@ public:
 template <class T>
 bool operator==(const nasty_list<T>& x, const nasty_list<T>& y) { return x.l_ == y.l_; }
 
+// Not really a mutex, but can play one in tests
+class nasty_mutex
+{
+public:
+     nasty_mutex() _NOEXCEPT {}
+     ~nasty_mutex() {}
+
+	nasty_mutex *operator& ()   { assert(false); return nullptr; }
+	template <typename T>
+	void operator, (const T &) { assert(false); }
+
+private:
+    nasty_mutex(const nasty_mutex&)            { assert(false); }
+    nasty_mutex& operator=(const nasty_mutex&) { assert(false); return *this; }
+
+public:
+    void lock()               {}
+    bool try_lock() _NOEXCEPT { return true; }
+    void unlock() _NOEXCEPT   {}
+
+    // Shared ownership
+    void lock_shared()     {}
+    bool try_lock_shared() { return true; }
+    void unlock_shared()   {}
+};
+
 #endif
diff --git a/test/support/platform_support.h b/test/support/platform_support.h
index 233e721ff515..f4c2247e0dfb 100644
--- a/test/support/platform_support.h
+++ b/test/support/platform_support.h
@@ -15,8 +15,6 @@
 #ifndef PLATFORM_SUPPORT_H
 #define PLATFORM_SUPPORT_H
 
-#include <__config>
-
 // locale names
 #ifdef _WIN32
 // WARNING: Windows does not support UTF-8 codepages.
@@ -54,8 +52,8 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string>
-#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
-#include <io.h> // _mktemp
+#if defined(_WIN32) || defined(__MINGW32__)
+#include <io.h> // _mktemp_s
 #else
 #include <unistd.h> // close
 #endif
@@ -67,17 +65,20 @@ extern "C" {
 }
 #endif
 
-#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
+#ifndef __CloudABI__
 inline
-std::string
-get_temp_file_name()
+std::string get_temp_file_name()
 {
-#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
-    char Path[MAX_PATH+1];
-    char FN[MAX_PATH+1];
+#if defined(__MINGW32__)
+    char Path[MAX_PATH + 1];
+    char FN[MAX_PATH + 1];
     do { } while (0 == GetTempPath(MAX_PATH+1, Path));
     do { } while (0 == GetTempFileName(Path, "libcxx", 0, FN));
     return FN;
+#elif defined(_WIN32)
+    char Name[] = "libcxx.XXXXXX";
+    if (_mktemp_s(Name, sizeof(Name)) != 0) abort();
+    return Name;
 #else
     std::string Name;
     int FD = -1;
@@ -93,6 +94,6 @@ get_temp_file_name()
     return Name;
 #endif
 }
-#endif // _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
+#endif // __CloudABI__
 
 #endif // PLATFORM_SUPPORT_H
diff --git a/test/support/propagate_const_helpers.h b/test/support/propagate_const_helpers.h
new file mode 100644
index 000000000000..581565a34270
--- /dev/null
+++ b/test/support/propagate_const_helpers.h
@@ -0,0 +1,119 @@
+ // A lightweight class, with pointer-like methods, that contains an int
+struct X
+{
+    int i_;
+
+    constexpr const int &operator*() const { return i_; }
+    constexpr int &operator*() { return i_; }
+    constexpr const int *get() const { return &i_; }
+    constexpr int *get() { return &i_; }
+    constexpr const int *operator->() const { return &i_; }
+    constexpr int *operator->() { return &i_; }
+
+    constexpr X(int i) : i_(i) {}
+};
+
+struct XWithImplicitIntStarConversion
+{
+    int i_;
+
+    constexpr const int &operator*() const { return i_; }
+    constexpr int &operator*() { return i_; }
+    constexpr const int *get() const { return &i_; }
+    constexpr int *get() { return &i_; }
+    constexpr const int *operator->() const { return &i_; }
+    constexpr int *operator->() { return &i_; }
+    constexpr operator int* () { return &i_; }
+
+    constexpr XWithImplicitIntStarConversion(int i) : i_(i) {}
+};
+
+struct XWithImplicitConstIntStarConversion
+{
+    int i_;
+
+    constexpr const int &operator*() const { return i_; }
+    constexpr int &operator*() { return i_; }
+    constexpr const int *get() const { return &i_; }
+    constexpr int *get() { return &i_; }
+    constexpr const int *operator->() const { return &i_; }
+    constexpr int *operator->() { return &i_; }
+    constexpr operator const int* () const { return &i_; }
+
+    constexpr XWithImplicitConstIntStarConversion(int i) : i_(i) {}
+};
+
+struct ExplicitX
+{
+    int i_;
+
+    constexpr const int &operator*() const { return i_; }
+    constexpr int &operator*() { return i_; }
+    constexpr const int *get() const { return &i_; }
+    constexpr int *get() { return &i_; }
+    constexpr const int *operator->() const { return &i_; }
+    constexpr int *operator->() { return &i_; }
+
+    constexpr explicit ExplicitX(int i) : i_(i) {}
+};
+
+struct MoveConstructibleFromX
+{
+    int i_;
+
+    constexpr const int &operator*() const { return i_; }
+    constexpr int &operator*() { return i_; }
+    constexpr const int *get() const { return &i_; }
+    constexpr int *get() { return &i_; }
+    constexpr const int *operator->() const { return &i_; }
+    constexpr int *operator->() { return &i_; }
+
+    constexpr MoveConstructibleFromX(int i) : i_(i) {}
+    constexpr MoveConstructibleFromX(X&& x) : i_(x.i_) {}
+};
+
+struct ExplicitMoveConstructibleFromX
+{
+    int i_;
+
+    constexpr const int &operator*() const { return i_; }
+    constexpr int &operator*() { return i_; }
+    constexpr const int *get() const { return &i_; }
+    constexpr int *get() { return &i_; }
+    constexpr const int *operator->() const { return &i_; }
+    constexpr int *operator->() { return &i_; }
+
+    constexpr ExplicitMoveConstructibleFromX(int i) : i_(i) {}
+    constexpr explicit ExplicitMoveConstructibleFromX(X&& x) : i_(x.i_) {}
+};
+
+struct CopyConstructibleFromX
+{
+    int i_;
+
+    constexpr const int &operator*() const { return i_; }
+    constexpr int &operator*() { return i_; }
+    constexpr const int *get() const { return &i_; }
+    constexpr int *get() { return &i_; }
+    constexpr const int *operator->() const { return &i_; }
+    constexpr int *operator->() { return &i_; }
+
+    constexpr CopyConstructibleFromX(int i) : i_(i) {}
+    constexpr CopyConstructibleFromX(const X& x) : i_(x.i_) {}
+};
+
+struct ExplicitCopyConstructibleFromX
+{
+    int i_;
+
+    constexpr const int &operator*() const { return i_; }
+    constexpr int &operator*() { return i_; }
+    constexpr const int *get() const { return &i_; }
+    constexpr int *get() { return &i_; }
+    constexpr const int *operator->() const { return &i_; }
+    constexpr int *operator->() { return &i_; }
+
+    constexpr ExplicitCopyConstructibleFromX(int i) : i_(i) {}
+    constexpr explicit ExplicitCopyConstructibleFromX(const X& x) : i_(x.i_) {}
+};
+
diff --git a/test/support/rapid-cxx-test.hpp b/test/support/rapid-cxx-test.hpp
new file mode 100644
index 000000000000..a25bda53109c
--- /dev/null
+++ b/test/support/rapid-cxx-test.hpp
@@ -0,0 +1,847 @@
+#ifndef RAPID_CXX_TEST_HPP
+#define RAPID_CXX_TEST_HPP
+
+# include <cstddef>
+# include <cstdlib>
+# include <cstdio>
+# include <cstring>
+# include <cassert>
+
+#include "test_macros.h"
+
+#if !defined(RAPID_CXX_TEST_NO_SYSTEM_HEADER) || !defined(__GNUC__)
+#pragma GCC system_header
+#endif
+
+# define RAPID_CXX_TEST_PP_CAT(x, y) RAPID_CXX_TEST_PP_CAT_2(x, y)
+# define RAPID_CXX_TEST_PP_CAT_2(x, y) x##y
+
+# define RAPID_CXX_TEST_PP_STR(...) RAPID_CXX_TEST_PP_STR_2(__VA_ARGS__)
+# define RAPID_CXX_TEST_PP_STR_2(...) #__VA_ARGS__
+
+# if defined(__GNUC__)
+#   define TEST_FUNC_NAME() __PRETTY_FUNCTION__
+#   define RAPID_CXX_TEST_UNUSED __attribute__((unused))
+# else
+#   define TEST_FUNC_NAME() __func__
+#   define RAPID_CXX_TEST_UNUSED
+# endif
+
+////////////////////////////////////////////////////////////////////////////////
+//                          TEST_SUITE
+////////////////////////////////////////////////////////////////////////////////
+# define TEST_SUITE(Name)                                           \
+namespace Name                                                      \
+{                                                                   \
+    inline ::rapid_cxx_test::test_suite & get_test_suite()          \
+    {                                                               \
+        static ::rapid_cxx_test::test_suite m_suite(#Name);         \
+        return m_suite;                                             \
+    }                                                               \
+                                                                    \
+    inline int unit_test_main(int, char**)                          \
+    {                                                               \
+        ::rapid_cxx_test::test_runner runner(get_test_suite());     \
+        return runner.run();                                        \
+    }                                                               \
+}                                                                   \
+int main(int argc, char **argv)                                     \
+{                                                                   \
+    return Name::unit_test_main(argc, argv);                        \
+}                                                                   \
+namespace Name                                                      \
+{ /* namespace closed in TEST_SUITE_END */
+#
+
+////////////////////////////////////////////////////////////////////////////////
+//                         TEST_SUITE_END
+////////////////////////////////////////////////////////////////////////////////
+# define TEST_SUITE_END()                                       \
+} /* namespace opened in TEST_SUITE(...) */
+#
+
+////////////////////////////////////////////////////////////////////////////////
+//                          TEST_CASE
+////////////////////////////////////////////////////////////////////////////////
+
+# if !defined(__clang__)
+#
+# define TEST_CASE(Name)                                                                                \
+    void Name();                                                                                        \
+    static void RAPID_CXX_TEST_PP_CAT(Name, _invoker)()                                                 \
+    {                                                                                                   \
+        Name();                                                                                         \
+    }                                                                                                   \
+    static ::rapid_cxx_test::registrar                                                                  \
+    RAPID_CXX_TEST_PP_CAT(rapid_cxx_test_registrar_, Name)(                                         \
+        get_test_suite()                                                                                \
+      , ::rapid_cxx_test::test_case(__FILE__, #Name, __LINE__, & RAPID_CXX_TEST_PP_CAT(Name, _invoker)) \
+      );                                                                                                \
+    void Name()
+#
+# else /* __clang__ */
+#
+# define TEST_CASE(Name)                                                                                \
+    void Name();                                                                                        \
+    static void RAPID_CXX_TEST_PP_CAT(Name, _invoker)()                                                 \
+    {                                                                                                   \
+        Name();                                                                                         \
+    }                                                                                                   \
+    _Pragma("clang diagnostic push")                                                                    \
+    _Pragma("clang diagnostic ignored \"-Wglobal-constructors\"")                                       \
+    static ::rapid_cxx_test::registrar                                                                  \
+    RAPID_CXX_TEST_PP_CAT(rapid_cxx_test_registrar_, Name)(                                         \
+        get_test_suite()                                                                                \
+      , ::rapid_cxx_test::test_case(__FILE__, #Name, __LINE__, & RAPID_CXX_TEST_PP_CAT(Name, _invoker)) \
+      );                                                                                                \
+    _Pragma("clang diagnostic pop")                                                                     \
+    void Name()
+#
+# endif /* !defined(__clang__) */
+
+
+# define TEST_SET_CHECKPOINT() ::rapid_cxx_test::set_checkpoint(__FILE__, TEST_FUNC_NAME(), __LINE__)
+
+#define RAPID_CXX_TEST_OUTCOME()
+
+////////////////////////////////////////////////////////////////////////////////
+//                              TEST_UNSUPPORTED
+////////////////////////////////////////////////////////////////////////////////
+# define TEST_UNSUPPORTED()                                                                 \
+    do {                                                                                    \
+        TEST_SET_CHECKPOINT();                                                              \
+        ::rapid_cxx_test::test_outcome m_f(                                                 \
+          ::rapid_cxx_test::failure_type::unsupported, __FILE__, TEST_FUNC_NAME(), __LINE__ \
+          , "", ""                                                                          \
+        );                                                                                  \
+        ::rapid_cxx_test::get_reporter().report(m_f);                                       \
+        return;                                                                             \
+    } while (false)
+#
+
+
+////////////////////////////////////////////////////////////////////////////////
+//                            BASIC ASSERTIONS
+////////////////////////////////////////////////////////////////////////////////
+# define TEST_WARN(...)                                                                \
+    do {                                                                               \
+        TEST_SET_CHECKPOINT();                                                         \
+        ::rapid_cxx_test::test_outcome m_f(                                            \
+            ::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
+            , "TEST_WARN(" #__VA_ARGS__ ")", ""                                        \
+            );                                                                         \
+        if (not (__VA_ARGS__)) {                                                       \
+            m_f.type = ::rapid_cxx_test::failure_type::warn;                           \
+        }                                                                              \
+        ::rapid_cxx_test::get_reporter().report(m_f);                                  \
+    } while (false)
+#
+
+# define TEST_CHECK(...)                                                               \
+    do {                                                                               \
+        TEST_SET_CHECKPOINT();                                                         \
+        ::rapid_cxx_test::test_outcome m_f(                                            \
+            ::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
+            , "TEST_CHECK(" #__VA_ARGS__ ")", ""                                       \
+            );                                                                         \
+        if (not (__VA_ARGS__)) {                                                       \
+            m_f.type = ::rapid_cxx_test::failure_type::check;                          \
+        }                                                                              \
+        ::rapid_cxx_test::get_reporter().report(m_f);                                  \
+    } while (false)
+#
+
+# define TEST_REQUIRE(...)                                                             \
+    do {                                                                               \
+        TEST_SET_CHECKPOINT();                                                         \
+        ::rapid_cxx_test::test_outcome m_f(                                            \
+            ::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
+            , "TEST_REQUIRE(" #__VA_ARGS__ ")", ""                                     \
+            );                                                                         \
+        if (not (__VA_ARGS__)) {                                                       \
+            m_f.type = ::rapid_cxx_test::failure_type::require;                        \
+        }                                                                              \
+        ::rapid_cxx_test::get_reporter().report(m_f);                                  \
+        if (m_f.type != ::rapid_cxx_test::failure_type::none) {                        \
+            return;                                                                    \
+        }                                                                              \
+    } while (false)
+#
+
+# define TEST_ASSERT(...)                                                              \
+    do {                                                                               \
+        TEST_SET_CHECKPOINT();                                                         \
+        ::rapid_cxx_test::test_outcome m_f(                                            \
+            ::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
+            , "TEST_ASSERT(" #__VA_ARGS__ ")", ""                                      \
+            );                                                                         \
+        if (not (__VA_ARGS__)) {                                                       \
+            m_f.type = ::rapid_cxx_test::failure_type::assert;                         \
+        }                                                                              \
+        ::rapid_cxx_test::get_reporter().report(m_f);                                  \
+        if (m_f.type != ::rapid_cxx_test::failure_type::none) {                        \
+            std::abort();                                                              \
+        }                                                                              \
+    } while (false)
+#
+
+////////////////////////////////////////////////////////////////////////////////
+//                    TEST_CHECK_NO_THROW / TEST_CHECK_THROW
+////////////////////////////////////////////////////////////////////////////////
+#ifndef TEST_HAS_NO_EXCEPTIONS
+
+# define TEST_CHECK_NO_THROW(...)                                                      \
+    do {                                                                               \
+        TEST_SET_CHECKPOINT();                                                         \
+        ::rapid_cxx_test::test_outcome m_f(                                            \
+            ::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
+            , "TEST_CHECK_NO_THROW(" #__VA_ARGS__ ")", ""                              \
+            );                                                                         \
+        try {                                                                          \
+            (static_cast<void>(__VA_ARGS__));                                          \
+        } catch (...) {                                                                \
+            m_f.type = ::rapid_cxx_test::failure_type::check;                          \
+        }                                                                              \
+        ::rapid_cxx_test::get_reporter().report(m_f);                                  \
+    } while (false)
+#
+
+# define TEST_CHECK_THROW(Except, ...)                                                 \
+    do {                                                                               \
+        TEST_SET_CHECKPOINT();                                                         \
+        ::rapid_cxx_test::test_outcome m_f(                                            \
+            ::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
+            , "TEST_CHECK_THROW(" #Except "," #__VA_ARGS__ ")", ""                     \
+            );                                                                         \
+        try {                                                                          \
+            (static_cast<void>(__VA_ARGS__));                                          \
+            m_f.type = ::rapid_cxx_test::failure_type::check;                          \
+        } catch (Except const &) {}                                                    \
+        ::rapid_cxx_test::get_reporter().report(m_f);                                  \
+    } while (false)
+#
+
+#else // TEST_HAS_NO_EXCEPTIONS
+
+# define TEST_CHECK_NO_THROW(...)                                                      \
+    do {                                                                               \
+        TEST_SET_CHECKPOINT();                                                         \
+        ::rapid_cxx_test::test_outcome m_f(                                            \
+            ::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
+            , "TEST_CHECK_NO_THROW(" #__VA_ARGS__ ")", ""                              \
+            );                                                                         \
+        (static_cast<void>(__VA_ARGS__));                                              \
+        ::rapid_cxx_test::get_reporter().report(m_f);                                  \
+    } while (false)
+#
+
+#define TEST_CHECK_THROW(Except, ...) ((void)0)
+
+#endif // TEST_HAS_NO_EXCEPTIONS
+
+
+////////////////////////////////////////////////////////////////////////////////
+//                    TEST_REQUIRE_NO_THROW / TEST_REQUIRE_THROWs
+////////////////////////////////////////////////////////////////////////////////
+#ifndef TEST_HAS_NO_EXCEPTIONS
+
+# define TEST_REQUIRE_NO_THROW(...)                                                    \
+    do {                                                                               \
+        TEST_SET_CHECKPOINT();                                                         \
+        ::rapid_cxx_test::test_outcome m_f(                                            \
+            ::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
+            , "TEST_REQUIRE_NO_THROW(" #__VA_ARGS__ ")", ""                            \
+            );                                                                         \
+        try {                                                                          \
+            (static_cast<void>(__VA_ARGS__));                                          \
+        } catch (...) {                                                                \
+            m_f.type = ::rapid_cxx_test::failure_type::require;                        \
+        }                                                                              \
+        ::rapid_cxx_test::get_reporter().report(m_f);                                  \
+        if (m_f.type != ::rapid_cxx_test::failure_type::none) {                        \
+            return;                                                                    \
+        }                                                                              \
+    } while (false)
+#
+
+# define TEST_REQUIRE_THROW(Except, ...)                                               \
+    do {                                                                               \
+        TEST_SET_CHECKPOINT();                                                         \
+        ::rapid_cxx_test::test_outcome m_f(                                            \
+            ::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
+            , "TEST_REQUIRE_THROW(" #Except "," #__VA_ARGS__ ")", ""                   \
+            );                                                                         \
+        try {                                                                          \
+            (static_cast<void>(__VA_ARGS__));                                          \
+            m_f.type = ::rapid_cxx_test::failure_type::require;                        \
+        } catch (Except const &) {}                                                    \
+        ::rapid_cxx_test::get_reporter().report(m_f);                                  \
+        if (m_f.type != ::rapid_cxx_test::failure_type::none) {                        \
+            return;                                                                    \
+        }                                                                              \
+    } while (false)
+#
+
+#else // TEST_HAS_NO_EXCEPTIONS
+
+# define TEST_REQUIRE_NO_THROW(...)                                                    \
+    do {                                                                               \
+        TEST_SET_CHECKPOINT();                                                         \
+        ::rapid_cxx_test::test_outcome m_f(                                            \
+            ::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
+            , "TEST_REQUIRE_NO_THROW(" #__VA_ARGS__ ")", ""                            \
+            );                                                                         \
+        (static_cast<void>(__VA_ARGS__));                                              \
+        ::rapid_cxx_test::get_reporter().report(m_f);                                  \
+    } while (false)
+#
+
+#define TEST_REQUIRE_THROW(Except, ...) ((void)0)
+
+#endif // TEST_HAS_NO_EXCEPTIONS
+
+////////////////////////////////////////////////////////////////////////////////
+//                    TEST_ASSERT_NO_THROW / TEST_ASSERT_THROW
+////////////////////////////////////////////////////////////////////////////////
+#ifndef TEST_HAS_NO_EXCEPTIONS
+
+# define TEST_ASSERT_NO_THROW(...)                                                     \
+    do {                                                                               \
+        TEST_SET_CHECKPOINT();                                                         \
+        ::rapid_cxx_test::test_outcome m_f(                                            \
+            ::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
+            , "TEST_ASSERT_NO_THROW(" #__VA_ARGS__ ")", ""                             \
+            );                                                                         \
+        try {                                                                          \
+            (static_cast<void>(__VA_ARGS__));                                          \
+        } catch (...) {                                                                \
+            m_f.type = ::rapid_cxx_test::failure_type::assert;                         \
+        }                                                                              \
+        ::rapid_cxx_test::get_reporter().report(m_f);                                  \
+        if (m_f.type != ::rapid_cxx_test::failure_type::none) {                        \
+            std::abort();                                                              \
+        }                                                                              \
+    } while (false)
+#
+
+# define TEST_ASSERT_THROW(Except, ...)                                                \
+    do {                                                                               \
+        TEST_SET_CHECKPOINT();                                                         \
+        ::rapid_cxx_test::test_outcome m_f(                                            \
+            ::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
+            , "TEST_ASSERT_THROW(" #Except "," #__VA_ARGS__ ")", ""                    \
+            );                                                                         \
+        try {                                                                          \
+            (static_cast<void>(__VA_ARGS__));                                          \
+            m_f.type = ::rapid_cxx_test::failure_type::assert;                         \
+        } catch (Except const &) {}                                                    \
+        ::rapid_cxx_test::get_reporter().report(m_f);                                  \
+        if (m_f.type != ::rapid_cxx_test::failure_type::none) {                        \
+            std::abort();                                                              \
+        }                                                                              \
+    } while (false)
+#
+
+#else // TEST_HAS_NO_EXCEPTIONS
+
+# define TEST_ASSERT_NO_THROW(...)                                                     \
+    do {                                                                               \
+        TEST_SET_CHECKPOINT();                                                         \
+        ::rapid_cxx_test::test_outcome m_f(                                            \
+            ::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
+            , "TEST_ASSERT_NO_THROW(" #__VA_ARGS__ ")", ""                             \
+            );                                                                         \
+        (static_cast<void>(__VA_ARGS__));                                              \
+        ::rapid_cxx_test::get_reporter().report(m_f);                                  \
+    } while (false)
+#
+
+#define TEST_ASSERT_THROW(Except, ...) ((void)0)
+
+#endif // TEST_HAS_NO_EXCEPTIONS
+
+////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////
+
+# define TEST_WARN_EQUAL_COLLECTIONS(...)                                              \
+    do {                                                                               \
+        TEST_SET_CHECKPOINT();                                                         \
+        ::rapid_cxx_test::test_outcome m_f(                                            \
+          ::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__   \
+          , "TEST_WARN_EQUAL_COLLECTIONS(" #__VA_ARGS__ ")", ""                        \
+        );                                                                             \
+        if (not ::rapid_cxx_test::detail::check_equal_collections_impl(__VA_ARGS__)) { \
+            m_f.type = ::rapid_cxx_test::failure_type::warn;                           \
+        }                                                                              \
+        ::rapid_cxx_test::get_reporter().report(m_f);                                  \
+    } while (false)
+#
+
+# define TEST_CHECK_EQUAL_COLLECTIONS(...)                                             \
+    do {                                                                               \
+        TEST_SET_CHECKPOINT();                                                         \
+        ::rapid_cxx_test::test_outcome m_f(                                            \
+          ::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__   \
+          , "TEST_CHECK_EQUAL_COLLECTIONS(" #__VA_ARGS__ ")", ""                       \
+        );                                                                             \
+        if (not ::rapid_cxx_test::detail::check_equal_collections_impl(__VA_ARGS__)) { \
+            m_f.type = ::rapid_cxx_test::failure_type::check;                          \
+        }                                                                              \
+        ::rapid_cxx_test::get_reporter().report(m_f);                                  \
+    } while (false)
+#
+
+# define TEST_REQUIRE_EQUAL_COLLECTIONS(...)                                           \
+    do {                                                                               \
+        TEST_SET_CHECKPOINT();                                                         \
+        ::rapid_cxx_test::test_outcome m_f(                                            \
+          ::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__   \
+          , "TEST_REQUIRE_EQUAL_COLLECTIONS(" #__VA_ARGS__ ")", ""                     \
+        );                                                                             \
+        if (not ::rapid_cxx_test::detail::check_equal_collections_impl(__VA_ARGS__)) { \
+            m_f.type = ::rapid_cxx_test::failure_type::require;                        \
+        }                                                                              \
+        ::rapid_cxx_test::get_reporter().report(m_f);                                  \
+        if (m_f.type != ::rapid_cxx_test::failure_type::none) {                        \
+            return;                                                                    \
+        }                                                                              \
+    } while (false)
+#
+
+# define TEST_ASSERT_EQUAL_COLLECTIONS(...)                                            \
+    do {                                                                               \
+        TEST_SET_CHECKPOINT();                                                         \
+        ::rapid_cxx_test::test_outcome m_f(                                            \
+          ::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__   \
+          , "TEST_ASSERT_EQUAL_COLLECTIONS(" #__VA_ARGS__ ")", ""                      \
+        );                                                                             \
+        if (not ::rapid_cxx_test::detail::check_equal_collections_impl(__VA_ARGS__)) { \
+            m_f.type = ::rapid_cxx_test::failure_type::assert;                         \
+        }                                                                              \
+        ::rapid_cxx_test::get_reporter().report(m_f);                                  \
+        if (m_f.type != ::rapid_cxx_test::failure_type::none) {                        \
+          ::std::abort();                                                              \
+        }                                                                              \
+    } while (false)
+#
+
+namespace rapid_cxx_test
+{
+    typedef void (*invoker_t)();
+
+    ////////////////////////////////////////////////////////////////////////////
+    struct test_case
+    {
+        test_case()
+            : file(""), func(""), line(0), invoke(NULL)
+        {}
+
+        test_case(const char* file1, const char* func1, std::size_t line1,
+                  invoker_t invoke1)
+            : file(file1), func(func1), line(line1), invoke(invoke1)
+        {}
+
+        const char *file;
+        const char *func;
+        std::size_t line;
+        invoker_t invoke;
+    };
+
+    ////////////////////////////////////////////////////////////////////////////
+    struct failure_type
+    {
+        enum enum_type {
+            none,
+            unsupported,
+            warn,
+            check,
+            require,
+            assert,
+            uncaught_exception
+        };
+    };
+
+    typedef failure_type::enum_type failure_type_t;
+
+    ////////////////////////////////////////////////////////////////////////////
+    struct test_outcome
+    {
+        test_outcome()
+            : type(failure_type::none),
+              file(""), func(""), line(0),
+              expression(""), message("")
+        {}
+
+        test_outcome(failure_type_t type1, const char* file1, const char* func1,
+                     std::size_t line1, const char* expression1,
+                     const char* message1)
+            : type(type1), file(file1), func(func1), line(line1),
+              expression(expression1), message(message1)
+        {
+            trim_func_string();
+        }
+
+        failure_type_t type;
+        const char *file;
+        const char *func;
+        std::size_t line;
+        const char *expression;
+        const char *message;
+
+    private:
+        void trim_file_string() {
+            const char* f_start  = file;
+            const char* prev_start = f_start;
+            const char* last_start = f_start;
+            char last;
+            while ((last = *f_start) != '\0') {
+                ++f_start;
+                if (last == '/' && *f_start) {
+                    prev_start = last_start;
+                    last_start = f_start;
+                }
+            }
+            file = prev_start;
+        }
+      void trim_func_string() {
+          const char* void_loc = ::strstr(func, "void ");
+          if (void_loc == func) {
+              func += strlen("void ");
+          }
+          const char* namespace_loc = ::strstr(func, "::");
+          if (namespace_loc) {
+              func = namespace_loc + 2;
+          }
+      }
+    };
+
+    ////////////////////////////////////////////////////////////////////////////
+    struct checkpoint
+    {
+        const char *file;
+        const char *func;
+        std::size_t line;
+    };
+
+    namespace detail
+    {
+        inline checkpoint & global_checkpoint()
+        {
+            static checkpoint cp = {"", "", 0};
+            return cp;
+        }
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+    inline void set_checkpoint(const char* file, const char* func, std::size_t line)
+    {
+        checkpoint& cp = detail::global_checkpoint();
+        cp.file = file;
+        cp.func = func;
+        cp.line = line;
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+    inline checkpoint const & get_checkpoint()
+    {
+        return detail::global_checkpoint();
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+    class test_suite
+    {
+    public:
+        typedef test_case const* iterator;
+        typedef iterator const_iterator;
+
+    public:
+        test_suite(const char *xname)
+          : m_name(xname), m_tests(), m_size(0)
+        {
+            assert(xname);
+        }
+
+    public:
+        const char *name() const { return m_name; }
+
+        std::size_t size() const { return m_size; }
+
+        test_case const & operator[](std::size_t i) const
+        {
+            assert(i < m_size);
+            return m_tests[i];
+        }
+
+        const_iterator begin() const
+        { return m_tests; }
+
+        const_iterator end() const
+        {
+            return m_tests + m_size;
+        }
+
+    public:
+        std::size_t register_test(test_case tc)
+        {
+            static std::size_t test_case_max = sizeof(m_tests) / sizeof(test_case);
+            assert(m_size < test_case_max);
+            m_tests[m_size] = tc;
+            return m_size++;
+        }
+
+    private:
+        test_suite(test_suite const &);
+        test_suite & operator=(test_suite const &);
+
+    private:
+        const char* m_name;
+        // Since fast compile times in a priority, we use simple containers
+        // with hard limits.
+        test_case m_tests[256];
+        std::size_t m_size;
+    };
+
+    ////////////////////////////////////////////////////////////////////////////
+    class registrar
+    {
+    public:
+        registrar(test_suite & st, test_case tc)
+        {
+            st.register_test(tc);
+        }
+    };
+
+    ////////////////////////////////////////////////////////////////////////////
+    class test_reporter
+    {
+    public:
+        test_reporter()
+            : m_testcases(0), m_testcase_failures(0), m_unsupported(0),
+              m_assertions(0), m_warning_failures(0), m_check_failures(0),
+              m_require_failures(0), m_uncaught_exceptions(0), m_failure()
+        {
+        }
+
+        void test_case_begin()
+        {
+            ++m_testcases;
+            clear_failure();
+        }
+
+        void test_case_end()
+        {
+            if (m_failure.type != failure_type::none
+                && m_failure.type !=  failure_type::unsupported) {
+                ++m_testcase_failures;
+            }
+        }
+
+# if defined(__GNUC__)
+#   pragma GCC diagnostic push
+#   pragma GCC diagnostic ignored "-Wswitch-default"
+# endif
+        // Each assertion and failure is reported through this function.
+        void report(test_outcome o)
+        {
+            ++m_assertions;
+            switch (o.type)
+            {
+            case failure_type::none:
+                break;
+            case failure_type::unsupported:
+                ++m_unsupported;
+                m_failure = o;
+                break;
+            case failure_type::warn:
+                ++m_warning_failures;
+                report_error(o);
+                break;
+            case failure_type::check:
+                ++m_check_failures;
+                report_error(o);
+                m_failure = o;
+                break;
+            case failure_type::require:
+                ++m_require_failures;
+                report_error(o);
+                m_failure = o;
+                break;
+            case failure_type::assert:
+                report_error(o);
+                break;
+            case failure_type::uncaught_exception:
+                ++m_uncaught_exceptions;
+                std::fprintf(stderr
+                    , "Test case FAILED with uncaught exception:\n"
+                      "    last checkpoint near %s::%lu %s\n\n"
+                    , o.file, o.line, o.func
+                    );
+                m_failure = o;
+                break;
+            }
+        }
+# if defined(__GNUC__)
+#   pragma GCC diagnostic pop
+# endif
+
+        test_outcome current_failure() const
+        {
+            return m_failure;
+        }
+
+        void clear_failure()
+        {
+            m_failure.type = failure_type::none;
+            m_failure.file = "";
+            m_failure.func = "";
+            m_failure.line = 0;
+            m_failure.expression = "";
+            m_failure.message = "";
+        }
+
+        std::size_t test_case_count() const
+        { return m_testcases; }
+
+        std::size_t test_case_failure_count() const
+        { return m_testcase_failures; }
+
+        std::size_t unsupported_count() const
+        { return m_unsupported; }
+
+        std::size_t assertion_count() const
+        { return m_assertions; }
+
+        std::size_t warning_failure_count() const
+        { return m_warning_failures; }
+
+        std::size_t check_failure_count() const
+        { return m_check_failures; }
+
+        std::size_t require_failure_count() const
+        { return m_require_failures; }
+
+        std::size_t failure_count() const
+        { return m_check_failures + m_require_failures + m_uncaught_exceptions; }
+
+        // Print a summary of what was run and the outcome.
+        void print_summary(const char* suitename) const
+        {
+            FILE* out = failure_count() ? stderr : stdout;
+            std::size_t testcases_run = m_testcases - m_unsupported;
+            std::fprintf(out, "Summary for testsuite %s:\n", suitename);
+            std::fprintf(out, "    %lu of %lu test cases passed.\n", testcases_run - m_testcase_failures, testcases_run);
+            std::fprintf(out, "    %lu of %lu assertions passed.\n", m_assertions - (m_warning_failures + m_check_failures + m_require_failures), m_assertions);
+            std::fprintf(out, "    %lu unsupported test case%s.\n", m_unsupported, (m_unsupported != 1 ? "s" : ""));
+        }
+
+    private:
+        test_reporter(test_reporter const &);
+        test_reporter const & operator=(test_reporter const &);
+
+        void report_error(test_outcome o) const
+        {
+            std::fprintf(stderr, "In %s:%lu Assertion %s failed.\n    in file: %s\n    %s\n"
+                , o.func, o.line, o.expression, o.file,  o.message ? o.message : ""
+              );
+        }
+
+    private:
+        // counts of testcases, failed testcases, and unsupported testcases.
+        std::size_t m_testcases;
+        std::size_t m_testcase_failures;
+        std::size_t m_unsupported;
+
+        // counts of assertions and assertion failures.
+        std::size_t m_assertions;
+        std::size_t m_warning_failures;
+        std::size_t m_check_failures;
+        std::size_t m_require_failures;
+        std::size_t m_uncaught_exceptions;
+
+        // The last failure. This is cleared between testcases.
+        test_outcome m_failure;
+    };
+
+    ////////////////////////////////////////////////////////////////////////////
+    inline test_reporter & get_reporter()
+    {
+        static test_reporter o;
+        return o;
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+    class test_runner
+    {
+    public:
+        test_runner(test_suite & ts)
+          : m_ts(ts)
+        {}
+
+    public:
+        int run()
+        {
+            // for each testcase
+            for (test_suite::const_iterator b = m_ts.begin(), e = m_ts.end();
+                 b != e; ++b)
+            {
+                test_case const& tc = *b;
+                set_checkpoint(tc.file, tc.func, tc.line);
+                get_reporter().test_case_begin();
+#ifndef TEST_HAS_NO_EXCEPTIONS
+                try {
+#endif
+                    tc.invoke();
+#ifndef TEST_HAS_NO_EXCEPTIONS
+                } catch (...) {
+                    test_outcome o;
+                    o.type = failure_type::uncaught_exception;
+                    o.file = get_checkpoint().file;
+                    o.func = get_checkpoint().func;
+                    o.line = get_checkpoint().line;
+                    o.expression = "";
+                    o.message = "";
+                    get_reporter().report(o);
+                }
+#endif
+                get_reporter().test_case_end();
+            }
+            auto exit_code = get_reporter().failure_count() ? EXIT_FAILURE : EXIT_SUCCESS;
+            if (exit_code == EXIT_FAILURE)
+                get_reporter().print_summary(m_ts.name());
+            return exit_code;
+        }
+
+    private:
+        test_runner(test_runner const &);
+        test_runner operator=(test_runner const &);
+
+        test_suite & m_ts;
+    };
+
+    namespace detail
+    {
+        template <class Iter1, class Iter2>
+        bool check_equal_collections_impl(
+            Iter1 start1, Iter1 const end1
+          , Iter2 start2, Iter2 const end2
+          )
+        {
+            while (start1 != end1 && start2 != end2) {
+                if (*start1 != *start2) {
+                    return false;
+                }
+                ++start1; ++start2;
+            }
+            return (start1 == end1 && start2 == end2);
+        }
+    }                                                       // namespace detail
+
+}                                                    // namespace rapid_cxx_test
+
+
+# if defined(__GNUC__)
+#   pragma GCC diagnostic pop
+# endif
+
+#endif /* RAPID_CXX_TEST_HPP */
diff --git a/test/support/test.support/test_convertible_header.pass.cpp b/test/support/test.support/test_convertible_header.pass.cpp
new file mode 100644
index 000000000000..a56b84b4739c
--- /dev/null
+++ b/test/support/test.support/test_convertible_header.pass.cpp
@@ -0,0 +1,68 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// "support/test_convertible.hpp"
+
+#include "test_convertible.hpp"
+
+struct ImplicitDefault {
+  ImplicitDefault() {}
+};
+static_assert(test_convertible<ImplicitDefault>(), "Must be convertible");
+
+struct ExplicitDefault {
+  explicit ExplicitDefault() {}
+};
+static_assert(!test_convertible<ExplicitDefault>(), "Must not be convertible");
+
+struct ImplicitInt {
+  ImplicitInt(int) {}
+};
+static_assert(test_convertible<ImplicitInt, int>(), "Must be convertible");
+
+struct ExplicitInt {
+  explicit ExplicitInt(int) {}
+};
+static_assert(!test_convertible<ExplicitInt, int>(), "Must not be convertible");
+
+struct ImplicitCopy {
+  ImplicitCopy(ImplicitCopy const&) {}
+};
+static_assert(test_convertible<ImplicitCopy, ImplicitCopy>(), "Must be convertible");
+
+struct ExplicitCopy {
+  explicit ExplicitCopy(ExplicitCopy const&) {}
+};
+static_assert(!test_convertible<ExplicitCopy, ExplicitCopy>(), "Must not be convertible");
+
+struct ImplicitMove {
+  ImplicitMove(ImplicitMove&&) {}
+};
+static_assert(test_convertible<ImplicitMove, ImplicitMove>(), "Must be convertible");
+
+struct ExplicitMove {
+  explicit ExplicitMove(ExplicitMove&&) {}
+};
+static_assert(!test_convertible<ExplicitMove, ExplicitMove>(), "Must not be convertible");
+
+struct ImplicitArgs {
+  ImplicitArgs(int, int, int) {}
+};
+static_assert(test_convertible<ImplicitArgs, int, int, int>(), "Must be convertible");
+
+struct ExplicitArgs {
+  explicit ExplicitArgs(int, int, int) {}
+};
+static_assert(!test_convertible<ExplicitArgs, int, int, int>(), "Must not be convertible");
+
+int main() {
+    // Nothing to do
+}
diff --git a/test/support/test.support/test_macros_header_exceptions.fail.cpp b/test/support/test.support/test_macros_header_exceptions.fail.cpp
new file mode 100644
index 000000000000..ade2cd98fe08
--- /dev/null
+++ b/test/support/test.support/test_macros_header_exceptions.fail.cpp
@@ -0,0 +1,24 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// "support/test_macros.hpp"
+
+// #define TEST_HAS_NO_EXCEPTIONS
+
+#include "test_macros.h"
+
+int main() {
+#if defined(TEST_HAS_NO_EXCEPTIONS)
+    try { ((void)0); } catch (...) {} // expected-error {{exceptions disabled}}
+#else
+    try { ((void)0); } catch (...) {}
+#error exceptions enabled
+// expected-error@-1 {{exceptions enabled}}
+#endif
+}
diff --git a/test/support/test.support/test_macros_header_exceptions.pass.cpp b/test/support/test.support/test_macros_header_exceptions.pass.cpp
new file mode 100644
index 000000000000..589e148a0032
--- /dev/null
+++ b/test/support/test.support/test_macros_header_exceptions.pass.cpp
@@ -0,0 +1,24 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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: libcpp-no-exceptions
+
+// "support/test_macros.hpp"
+
+// #define TEST_HAS_NO_EXCEPTIONS
+
+#include "test_macros.h"
+
+#if defined(TEST_HAS_NO_EXCEPTIONS)
+#error macro defined unexpectedly
+#endif
+
+int main() {
+    try { ((void)0); } catch (...) {}
+}
diff --git a/test/support/test.support/test_macros_header_rtti.fail.cpp b/test/support/test.support/test_macros_header_rtti.fail.cpp
new file mode 100644
index 000000000000..851a6c601416
--- /dev/null
+++ b/test/support/test.support/test_macros_header_rtti.fail.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// "support/test_macros.hpp"
+
+// #define TEST_HAS_NO_RTTI
+
+#include "test_macros.h"
+
+struct A { virtual ~A() {} };
+struct B : A {};
+
+int main() {
+#if defined(TEST_HAS_NO_RTTI)
+    A* ptr = new B;
+    (void)dynamic_cast<B*>(ptr); // expected-error{{cannot use dynamic_cast}}
+#else
+    A* ptr = new B;
+    (void)dynamic_cast<B*>(ptr);
+#error RTTI enabled
+// expected-error@-1{{RTTI enabled}}
+#endif
+}
diff --git a/test/support/test.support/test_macros_header_rtti.pass.cpp b/test/support/test.support/test_macros_header_rtti.pass.cpp
new file mode 100644
index 000000000000..d189a0efc2fc
--- /dev/null
+++ b/test/support/test.support/test_macros_header_rtti.pass.cpp
@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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: libcpp-no-rtti
+
+// "support/test_macros.hpp"
+
+// #define TEST_HAS_NO_RTTI
+
+#include "test_macros.h"
+
+#if defined(TEST_HAS_NO_RTTI)
+#error Macro defined unexpectedly
+#endif
+
+struct A { virtual ~A() {} };
+struct B : A {};
+
+int main() {
+    A* ptr = new B;
+    (void)dynamic_cast<B*>(ptr);
+}
diff --git a/test/support/test_allocator.h b/test/support/test_allocator.h
index 3ca672f89a9b..466c7fabc66d 100644
--- a/test/support/test_allocator.h
+++ b/test/support/test_allocator.h
@@ -76,18 +76,22 @@ public:
             ++alloc_count;
             return (pointer)::operator new(n * sizeof(T));
         }
-    void deallocate(pointer p, size_type n)
+    void deallocate(pointer p, size_type)
         {assert(data_ >= 0); --alloc_count; ::operator delete((void*)p);}
     size_type max_size() const throw()
         {return UINT_MAX / sizeof(T);}
+#if TEST_STD_VER < 11
     void construct(pointer p, const T& val)
-        {::new(p) T(val);}
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    void construct(pointer p, T&& val)
-        {::new(p) T(std::move(val));}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    void destroy(pointer p) {p->~T();}
-
+        {::new(static_cast<void*>(p)) T(val);}
+#else
+    template <class U> void construct(pointer p, U&& val)
+        {::new(static_cast<void*>(p)) T(std::forward<U>(val));}
+#endif
+    void destroy(pointer p)
+        {
+            p->~T();
+            ((void)p); // Prevent MSVC's spurious unused warning
+        }
     friend bool operator==(const test_allocator& x, const test_allocator& y)
         {return x.data_ == y.data_;}
     friend bool operator!=(const test_allocator& x, const test_allocator& y)
@@ -136,16 +140,17 @@ public:
             ++alloc_count;
             return (pointer)::operator new (n * sizeof(T));
         }
-    void deallocate(pointer p, size_type n)
+    void deallocate(pointer p, size_type)
         {assert(data_ >= 0); --alloc_count; ::operator delete((void*)p); }
     size_type max_size() const throw()
         {return UINT_MAX / sizeof(T);}
+#if TEST_STD_VER < 11
     void construct(pointer p, const T& val)
-        {::new(p) T(val);}
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    void construct(pointer p, T&& val)
-        {::new(p) T(std::move(val));}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+        {::new(static_cast<void*>(p)) T(val);}
+#else
+    template <class U> void construct(pointer p, U&& val)
+        {::new(static_cast<void*>(p)) T(std::forward<U>(val));}
+#endif
     void destroy(pointer p) {p->~T();}
 
     friend bool operator==(const non_default_test_allocator& x, const non_default_test_allocator& y)
@@ -201,7 +206,7 @@ public:
         : data_(a.data_) {}
     T* allocate(std::size_t n)
         {return (T*)::operator new(n * sizeof(T));}
-    void deallocate(T* p, std::size_t n)
+    void deallocate(T* p, std::size_t)
         {::operator delete((void*)p);}
 
     other_allocator select_on_container_copy_construction() const
@@ -223,4 +228,82 @@ public:
 
 };
 
+#if TEST_STD_VER >= 11
+
+struct Ctor_Tag {};
+
+template <typename T> class TaggingAllocator;
+
+struct Tag_X {
+  // All constructors must be passed the Tag type.
+
+  // DefaultInsertable into vector<X, TaggingAllocator<X>>,
+  Tag_X(Ctor_Tag) {}
+  // CopyInsertable into vector<X, TaggingAllocator<X>>,
+  Tag_X(Ctor_Tag, const Tag_X&) {}
+  // MoveInsertable into vector<X, TaggingAllocator<X>>, and
+  Tag_X(Ctor_Tag, Tag_X&&) {}
+
+  // EmplaceConstructible into vector<X, TaggingAllocator<X>> from args.
+  template<typename... Args>
+  Tag_X(Ctor_Tag, Args&&...) { }
+
+  // not DefaultConstructible, CopyConstructible or MoveConstructible.
+  Tag_X() = delete;
+  Tag_X(const Tag_X&) = delete;
+  Tag_X(Tag_X&&) = delete;
+
+  // CopyAssignable.
+  Tag_X& operator=(const Tag_X&) { return *this; }
+
+  // MoveAssignable.
+  Tag_X& operator=(Tag_X&&) { return *this; }
+
+private:
+  // Not Destructible.
+  ~Tag_X() { }
+
+  // Erasable from vector<X, TaggingAllocator<X>>.
+  friend class TaggingAllocator<Tag_X>;
+};
+
+
+template<typename T>
+class TaggingAllocator {
+public:
+    using value_type = T;
+    TaggingAllocator() = default;
+
+    template<typename U>
+      TaggingAllocator(const TaggingAllocator<U>&) { }
+
+    T* allocate(std::size_t n) { return std::allocator<T>{}.allocate(n); }
+
+    void deallocate(T* p, std::size_t n) { std::allocator<T>{}.deallocate(p, n); }
+
+    template<typename... Args>
+    void construct(Tag_X* p, Args&&... args)
+    { ::new((void*)p) Tag_X(Ctor_Tag{}, std::forward<Args>(args)...); }
+
+    template<typename U, typename... Args>
+    void construct(U* p, Args&&... args)
+    { ::new((void*)p) U(std::forward<Args>(args)...); }
+
+    template<typename U, typename... Args>
+    void destroy(U* p)
+    { p->~U(); }
+};
+
+template<typename T, typename U>
+bool
+operator==(const TaggingAllocator<T>&, const TaggingAllocator<U>&)
+{ return true; }
+
+template<typename T, typename U>
+bool
+operator!=(const TaggingAllocator<T>&, const TaggingAllocator<U>&)
+{ return false; }
+#endif
+
+
 #endif  // TEST_ALLOCATOR_H
diff --git a/test/support/test_convertible.hpp b/test/support/test_convertible.hpp
new file mode 100644
index 000000000000..787cef6568f2
--- /dev/null
+++ b/test/support/test_convertible.hpp
@@ -0,0 +1,42 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SUPPORT_TEST_CONVERTIBLE_HPP
+#define SUPPORT_TEST_CONVERTIBLE_HPP
+
+// "test_convertible<Tp, Args...>()" is a metafunction used to check if 'Tp'
+// is implicitly convertible from 'Args...' for any number of arguments,
+// Unlike 'std::is_convertible' which only allows checking for single argument
+// conversions.
+
+#include <type_traits>
+
+#include "test_macros.h"
+
+#if TEST_STD_VER < 11
+#error test_convertible.hpp requires C++11 or newer
+#endif
+
+namespace detail {
+    template <class Tp> void eat_type(Tp);
+
+    template <class Tp, class ...Args>
+    constexpr auto test_convertible_imp(int)
+        -> decltype(eat_type<Tp>({std::declval<Args>()...}), true)
+    { return true; }
+
+    template <class Tp, class ...Args>
+    constexpr auto test_convertible_imp(long) -> bool { return false; }
+}
+
+template <class Tp, class ...Args>
+constexpr bool test_convertible()
+{ return detail::test_convertible_imp<Tp, Args...>(0); }
+
+#endif // SUPPORT_TEST_CONVERTIBLE_HPP
\ No newline at end of file
diff --git a/test/support/test_iterators.h b/test/support/test_iterators.h
index d814879fa272..d4a079971b15 100644
--- a/test/support/test_iterators.h
+++ b/test/support/test_iterators.h
@@ -12,6 +12,7 @@
 
 #include <iterator>
 #include <stdexcept>
+#include <cstddef>
 #include <cassert>
 
 #include "test_macros.h"
@@ -335,116 +336,137 @@ struct ThrowingIterator {
     typedef const T *                       pointer;
     typedef const T &                       reference;
 
-	enum ThrowingAction { TAIncrement, TADecrement, TADereference, TAAssignment, TAComparison };
-
-//	Constructors
-	ThrowingIterator ()
-		: begin_(nullptr), end_(nullptr), current_(nullptr), action_(TADereference), index_(0) {}
-	ThrowingIterator (const T *first, const T *last, size_t index = 0, ThrowingAction action = TADereference)
-		: begin_(first), end_(last), current_(first), action_(action), index_(index) {}
-	ThrowingIterator (const ThrowingIterator &rhs)
-		: begin_(rhs.begin_), end_(rhs.end_), current_(rhs.current_), action_(rhs.action_), index_(rhs.index_) {}
-	ThrowingIterator & operator= (const ThrowingIterator &rhs)
-	{
-	if (action_ == TAAssignment)
-	{
-		if (index_ == 0)
-			throw std::runtime_error ("throw from iterator assignment");
-		else
-			--index_;
-	}
-	begin_   = rhs.begin_;
-	end_     = rhs.end_;
-	current_ = rhs.current_;
-	action_  = rhs.action_;
-	index_   = rhs.index_;
-	return *this;
-	}
-
-//	iterator operations
-	reference operator*() const
-	{
-	if (action_ == TADereference)
-	{
-		if (index_ == 0)
-			throw std::runtime_error ("throw from iterator dereference");
-		else
-			--index_;
-	}
-	return *current_;
-	}
-
-	ThrowingIterator & operator++()
-	{
-	if (action_ == TAIncrement)
-	{
-		if (index_ == 0)
-			throw std::runtime_error ("throw from iterator increment");
-		else
-			--index_;
-	}
-	++current_;
-	return *this;
-	}
-	
-	ThrowingIterator operator++(int)
-	{
-		ThrowingIterator temp = *this;
-		++(*this);
-		return temp;
-	}
-
-	ThrowingIterator & operator--()
-	{
-	if (action_ == TADecrement)
-	{
-		if (index_ == 0)
-			throw std::runtime_error ("throw from iterator decrement");
-		else
-			--index_;
-	}
-	--current_;
-	return *this;
-	}
-
-	ThrowingIterator operator--(int) {
-		ThrowingIterator temp = *this;
-		--(*this);
-		return temp;
-	}
-
-	bool operator== (const ThrowingIterator &rhs) const
-	{
-	if (action_ == TAComparison)
-	{
-		if (index_ == 0)
-			throw std::runtime_error ("throw from iterator comparison");
-		else
-			--index_;
-	}
-	bool atEndL =     current_ == end_;
-	bool atEndR = rhs.current_ == rhs.end_;
-	if (atEndL != atEndR) return false;  // one is at the end (or empty), the other is not.
-	if (atEndL) return true;			 // both are at the end (or empty)
-	return current_ == rhs.current_;
-	}
+    enum ThrowingAction { TAIncrement, TADecrement, TADereference, TAAssignment, TAComparison };
+
+//  Constructors
+    ThrowingIterator ()
+        : begin_(nullptr), end_(nullptr), current_(nullptr), action_(TADereference), index_(0) {}
+    ThrowingIterator (const T *first, const T *last, size_t index = 0, ThrowingAction action = TADereference)
+        : begin_(first), end_(last), current_(first), action_(action), index_(index) {}
+    ThrowingIterator (const ThrowingIterator &rhs)
+        : begin_(rhs.begin_), end_(rhs.end_), current_(rhs.current_), action_(rhs.action_), index_(rhs.index_) {}
+    ThrowingIterator & operator= (const ThrowingIterator &rhs)
+    {
+    if (action_ == TAAssignment)
+    {
+        if (index_ == 0)
+#ifndef TEST_HAS_NO_EXCEPTIONS
+            throw std::runtime_error ("throw from iterator assignment");
+#else
+            assert(false);
+#endif
+
+        else
+            --index_;
+    }
+    begin_   = rhs.begin_;
+    end_     = rhs.end_;
+    current_ = rhs.current_;
+    action_  = rhs.action_;
+    index_   = rhs.index_;
+    return *this;
+    }
+
+//  iterator operations
+    reference operator*() const
+    {
+    if (action_ == TADereference)
+    {
+        if (index_ == 0)
+#ifndef TEST_HAS_NO_EXCEPTIONS
+            throw std::runtime_error ("throw from iterator dereference");
+#else
+            assert(false);
+#endif
+        else
+            --index_;
+    }
+    return *current_;
+    }
+
+    ThrowingIterator & operator++()
+    {
+    if (action_ == TAIncrement)
+    {
+        if (index_ == 0)
+#ifndef TEST_HAS_NO_EXCEPTIONS
+            throw std::runtime_error ("throw from iterator increment");
+#else
+            assert(false);
+#endif
+        else
+            --index_;
+    }
+    ++current_;
+    return *this;
+    }
+
+    ThrowingIterator operator++(int)
+    {
+        ThrowingIterator temp = *this;
+        ++(*this);
+        return temp;
+    }
+
+    ThrowingIterator & operator--()
+    {
+    if (action_ == TADecrement)
+    {
+        if (index_ == 0)
+#ifndef TEST_HAS_NO_EXCEPTIONS
+            throw std::runtime_error ("throw from iterator decrement");
+#else
+            assert(false);
+#endif
+        else
+            --index_;
+    }
+    --current_;
+    return *this;
+    }
+
+    ThrowingIterator operator--(int) {
+        ThrowingIterator temp = *this;
+        --(*this);
+        return temp;
+    }
+
+    bool operator== (const ThrowingIterator &rhs) const
+    {
+    if (action_ == TAComparison)
+    {
+        if (index_ == 0)
+#ifndef TEST_HAS_NO_EXCEPTIONS
+            throw std::runtime_error ("throw from iterator comparison");
+#else
+            assert(false);
+#endif
+        else
+            --index_;
+    }
+    bool atEndL =     current_ == end_;
+    bool atEndR = rhs.current_ == rhs.end_;
+    if (atEndL != atEndR) return false;  // one is at the end (or empty), the other is not.
+    if (atEndL) return true;             // both are at the end (or empty)
+    return current_ == rhs.current_;
+    }
 
 private:
-	const T* begin_;
-	const T* end_;
-	const T* current_;
-	ThrowingAction action_;
-	mutable size_t index_;
+    const T* begin_;
+    const T* end_;
+    const T* current_;
+    ThrowingAction action_;
+    mutable size_t index_;
 };
 
 template <typename T>
 bool operator== (const ThrowingIterator<T>& a, const ThrowingIterator<T>& b)
-{	return a.operator==(b); }
+{   return a.operator==(b); }
 
 template <typename T>
 bool operator!= (const ThrowingIterator<T>& a, const ThrowingIterator<T>& b)
-{	return !a.operator==(b); }
-	
+{   return !a.operator==(b); }
+
 template <typename T>
 struct NonThrowingIterator {
     typedef std::bidirectional_iterator_tag iterator_category;
@@ -453,75 +475,75 @@ struct NonThrowingIterator {
     typedef const T *                       pointer;
     typedef const T &                       reference;
 
-//	Constructors
-	NonThrowingIterator ()
-		: begin_(nullptr), end_(nullptr), current_(nullptr) {}
-	NonThrowingIterator (const T *first, const T* last)
-		: begin_(first), end_(last), current_(first) {}
-	NonThrowingIterator (const NonThrowingIterator &rhs)
-		: begin_(rhs.begin_), end_(rhs.end_), current_(rhs.current_) {}
-	NonThrowingIterator & operator= (const NonThrowingIterator &rhs) TEST_NOEXCEPT
-	{
-	begin_   = rhs.begin_;
-	end_     = rhs.end_;
-	current_ = rhs.current_;
-	return *this;
-	}
-
-//	iterator operations
-	reference operator*() const TEST_NOEXCEPT
-	{
-	return *current_;
-	}
-
-	NonThrowingIterator & operator++() TEST_NOEXCEPT
-	{
-	++current_;
-	return *this;
-	}
-	
-	NonThrowingIterator operator++(int) TEST_NOEXCEPT
-	{
-		NonThrowingIterator temp = *this;
-		++(*this);
-		return temp;
-	}
-
-	NonThrowingIterator & operator--() TEST_NOEXCEPT
-	{
-	--current_;
-	return *this;
-	}
-
-	NonThrowingIterator operator--(int) TEST_NOEXCEPT
-	{
-		NonThrowingIterator temp = *this;
-		--(*this);
-		return temp;
-	}
-
-	bool operator== (const NonThrowingIterator &rhs) const TEST_NOEXCEPT
-	{
-	bool atEndL =     current_ == end_;
-	bool atEndR = rhs.current_ == rhs.end_;
-	if (atEndL != atEndR) return false;  // one is at the end (or empty), the other is not.
-	if (atEndL) return true;			 // both are at the end (or empty)
-	return current_ == rhs.current_;
-	}
+//  Constructors
+    NonThrowingIterator ()
+        : begin_(nullptr), end_(nullptr), current_(nullptr) {}
+    NonThrowingIterator (const T *first, const T* last)
+        : begin_(first), end_(last), current_(first) {}
+    NonThrowingIterator (const NonThrowingIterator &rhs)
+        : begin_(rhs.begin_), end_(rhs.end_), current_(rhs.current_) {}
+    NonThrowingIterator & operator= (const NonThrowingIterator &rhs) TEST_NOEXCEPT
+    {
+    begin_   = rhs.begin_;
+    end_     = rhs.end_;
+    current_ = rhs.current_;
+    return *this;
+    }
+
+//  iterator operations
+    reference operator*() const TEST_NOEXCEPT
+    {
+    return *current_;
+    }
+
+    NonThrowingIterator & operator++() TEST_NOEXCEPT
+    {
+    ++current_;
+    return *this;
+    }
+
+    NonThrowingIterator operator++(int) TEST_NOEXCEPT
+    {
+        NonThrowingIterator temp = *this;
+        ++(*this);
+        return temp;
+    }
+
+    NonThrowingIterator & operator--() TEST_NOEXCEPT
+    {
+    --current_;
+    return *this;
+    }
+
+    NonThrowingIterator operator--(int) TEST_NOEXCEPT
+    {
+        NonThrowingIterator temp = *this;
+        --(*this);
+        return temp;
+    }
+
+    bool operator== (const NonThrowingIterator &rhs) const TEST_NOEXCEPT
+    {
+    bool atEndL =     current_ == end_;
+    bool atEndR = rhs.current_ == rhs.end_;
+    if (atEndL != atEndR) return false;  // one is at the end (or empty), the other is not.
+    if (atEndL) return true;             // both are at the end (or empty)
+    return current_ == rhs.current_;
+    }
 
 private:
-	const T* begin_;
-	const T* end_;
-	const T* current_;
+    const T* begin_;
+    const T* end_;
+    const T* current_;
 };
 
 template <typename T>
 bool operator== (const NonThrowingIterator<T>& a, const NonThrowingIterator<T>& b) TEST_NOEXCEPT
-{	return a.operator==(b); }
+{   return a.operator==(b); }
 
 template <typename T>
 bool operator!= (const NonThrowingIterator<T>& a, const NonThrowingIterator<T>& b) TEST_NOEXCEPT
-{	return !a.operator==(b); }
+{   return !a.operator==(b); }
 
 #undef DELETE_FUNCTION
 
diff --git a/test/support/test_macros.h b/test/support/test_macros.h
index c34e8cf7ef14..a072e31b77b7 100644
--- a/test/support/test_macros.h
+++ b/test/support/test_macros.h
@@ -11,6 +11,8 @@
 #ifndef SUPPORT_TEST_MACROS_HPP
 #define SUPPORT_TEST_MACROS_HPP
 
+#include <ciso646> // Get STL specific macros like _LIBCPP_VERSION
+
 #define TEST_CONCAT1(X, Y) X##Y
 #define TEST_CONCAT(X, Y) TEST_CONCAT1(X, Y)
 
@@ -33,6 +35,7 @@
 #endif
 
 /* Make a nice name for the standard version */
+#ifndef TEST_STD_VER
 #if  __cplusplus <= 199711L
 # define TEST_STD_VER 3
 #elif __cplusplus <= 201103L
@@ -40,15 +43,8 @@
 #elif __cplusplus <= 201402L
 # define TEST_STD_VER 14
 #else
-# define TEST_STD_VER 99    // greater than current standard
+# define TEST_STD_VER 16    // current year; greater than current standard
 #endif
-
-/* Features that were introduced in C++11 */
-#if TEST_STD_VER >= 11
-#define TEST_HAS_RVALUE_REFERENCES
-#define TEST_HAS_VARIADIC_TEMPLATES
-#define TEST_HAS_INITIALIZER_LISTS
-#define TEST_HAS_BASIC_CONSTEXPR
 #endif
 
 /* Features that were introduced in C++14 */
@@ -61,44 +57,27 @@
 #if TEST_STD_VER > 14
 #endif
 
-#if TEST_HAS_EXTENSION(cxx_decltype) || TEST_STD_VER >= 11
-#define TEST_DECLTYPE(T) decltype(T)
-#else
-#define TEST_DECLTYPE(T) __typeof__(T)
-#endif
-
 #if TEST_STD_VER >= 11
 #define TEST_CONSTEXPR constexpr
 #define TEST_NOEXCEPT noexcept
+# if TEST_STD_VER >= 14
+#   define TEST_CONSTEXPR_CXX14 constexpr
+# else
+#   define TEST_CONSTEXPR_CXX14
+# endif
 #else
 #define TEST_CONSTEXPR
+#define TEST_CONSTEXPR_CXX14
 #define TEST_NOEXCEPT
 #endif
 
-#if TEST_HAS_EXTENSION(cxx_static_assert) || TEST_STD_VER >= 11
-#  define TEST_STATIC_ASSERT(Expr, Msg) static_assert(Expr, Msg)
-#else
-#  define TEST_STATIC_ASSERT(Expr, Msg)                          \
-      typedef ::test_detail::static_assert_check<sizeof(         \
-          ::test_detail::static_assert_incomplete_test<(Expr)>)> \
-    TEST_CONCAT(test_assert, __LINE__)
-#
-#endif
-
-namespace test_detail {
-
-template <bool> struct static_assert_incomplete_test;
-template <> struct static_assert_incomplete_test<true> {};
-template <unsigned> struct static_assert_check {};
-
-} // end namespace test_detail
-
-
-#if !TEST_HAS_FEATURE(cxx_rtti) && !defined(__cxx_rtti)
+#if !TEST_HAS_FEATURE(cxx_rtti) && !defined(__cpp_rtti) \
+    && !defined(__GXX_RTTI)
 #define TEST_HAS_NO_RTTI
 #endif
 
-#if !TEST_HAS_FEATURE(cxx_exceptions) && !defined(__cxx_exceptions)
+#if !TEST_HAS_FEATURE(cxx_exceptions) && !defined(__cpp_exceptions) \
+     && !defined(__EXCEPTIONS)
 #define TEST_HAS_NO_EXCEPTIONS
 #endif
 
@@ -107,4 +86,36 @@ template <unsigned> struct static_assert_check {};
 #define TEST_HAS_SANITIZERS
 #endif
 
+#if defined(_LIBCPP_NORETURN)
+#define TEST_NORETURN _LIBCPP_NORETURN
+#else
+#define TEST_NORETURN [[noreturn]]
+#endif
+
+/* Macros for testing libc++ specific behavior and extensions */
+#if defined(_LIBCPP_VERSION)
+#define LIBCPP_ASSERT(...) assert(__VA_ARGS__)
+#define LIBCPP_STATIC_ASSERT(...) static_assert(__VA_ARGS__)
+#else
+#define LIBCPP_ASSERT(...) ((void)0)
+#define LIBCPP_STATIC_ASSERT(...) ((void)0)
+#endif
+
+#define ASSERT_NOEXCEPT(...) \
+    static_assert(noexcept(__VA_ARGS__), "Operation must be noexcept")
+
+#define ASSERT_NOT_NOEXCEPT(...) \
+    static_assert(!noexcept(__VA_ARGS__), "Operation must NOT be noexcept")
+
+namespace test_macros_detail {
+template <class T, class U>
+struct is_same { enum { value = 0};} ;
+template <class T>
+struct is_same<T, T> { enum {value = 1}; };
+} // namespace test_macros_detail
+
+#define ASSERT_SAME_TYPE(...) \
+    static_assert(test_macros_detail::is_same<__VA_ARGS__>::value, \
+                 "Types differ uexpectedly")
+
 #endif // SUPPORT_TEST_MACROS_HPP
diff --git a/test/support/test_memory_resource.hpp b/test/support/test_memory_resource.hpp
new file mode 100644
index 000000000000..e7b067cf631d
--- /dev/null
+++ b/test/support/test_memory_resource.hpp
@@ -0,0 +1,507 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SUPPORT_TEST_MEMORY_RESOURCE_HPP
+#define SUPPORT_TEST_MEMORY_RESOURCE_HPP
+
+#include <experimental/memory_resource>
+#include <memory>
+#include <type_traits>
+#include <cstddef>
+#include <cstdlib>
+#include <cstring>
+#include <cstdint>
+#include <cassert>
+#include "test_macros.h"
+
+struct AllocController;
+    // 'AllocController' is a concrete type that instruments and controls the
+    // behavior of of test allocators.
+
+template <class T>
+class CountingAllocator;
+    // 'CountingAllocator' is an basic implementation of the 'Allocator'
+    // requirements that use the 'AllocController' interface.
+
+template <class T>
+class MinAlignAllocator;
+    // 'MinAlignAllocator' is an instrumented test type which implements the
+    // 'Allocator' requirements. 'MinAlignAllocator' ensures that it *never*
+    // returns a pointer to over-aligned storage. For example
+    // 'MinAlignPointer<char>{}.allocate(...)' will never a 2-byte aligned
+    // pointer.
+
+template <class T>
+class NullAllocator;
+    // 'NullAllocator' is an instrumented test type which implements the
+    // 'Allocator' requirements except that 'allocator' and 'deallocate' are
+    // nops.
+
+
+#define DISALLOW_COPY(Type) \
+  Type(Type const&) = delete; \
+  Type& operator=(Type const&) = delete
+
+constexpr std::size_t MaxAlignV = alignof(std::max_align_t);
+
+struct TestException {};
+
+struct AllocController {
+    int copy_constructed = 0;
+    int move_constructed = 0;
+
+    int alive = 0;
+    int alloc_count = 0;
+    int dealloc_count = 0;
+    int is_equal_count = 0;
+
+    std::size_t alive_size;
+    std::size_t allocated_size;
+    std::size_t deallocated_size;
+
+    std::size_t last_size = 0;
+    std::size_t last_align = 0;
+    void * last_pointer = 0;
+
+    std::size_t last_alloc_size = 0;
+    std::size_t last_alloc_align = 0;
+    void * last_alloc_pointer = nullptr;
+
+    std::size_t last_dealloc_size = 0;
+    std::size_t last_dealloc_align = 0;
+    void * last_dealloc_pointer = nullptr;
+
+    bool throw_on_alloc = false;
+
+    AllocController() = default;
+
+    void countAlloc(void* p, size_t s, size_t a) {
+        ++alive;
+        ++alloc_count;
+        alive_size += s;
+        allocated_size += s;
+        last_pointer = last_alloc_pointer = p;
+        last_size = last_alloc_size = s;
+        last_align = last_alloc_align = a;
+    }
+
+    void countDealloc(void* p, size_t s, size_t a) {
+        --alive;
+        ++dealloc_count;
+        alive_size -= s;
+        deallocated_size += s;
+        last_pointer = last_dealloc_pointer = p;
+        last_size = last_dealloc_size = s;
+        last_align = last_dealloc_align = a;
+    }
+
+    void reset() { std::memset(this, 0, sizeof(*this)); }
+
+public:
+    bool checkAlloc(void* p, size_t s, size_t a) const {
+        return p == last_alloc_pointer &&
+               s == last_alloc_size &&
+               a == last_alloc_align;
+    }
+
+    bool checkAlloc(void* p, size_t s) const {
+        return p == last_alloc_pointer &&
+               s == last_alloc_size;
+    }
+
+    bool checkAllocAtLeast(void* p, size_t s, size_t a) const {
+        return p == last_alloc_pointer &&
+               s <= last_alloc_size &&
+               a <= last_alloc_align;
+    }
+
+    bool checkAllocAtLeast(void* p, size_t s) const {
+        return p == last_alloc_pointer &&
+               s <= last_alloc_size;
+    }
+
+    bool checkDealloc(void* p, size_t s, size_t a) const {
+        return p == last_dealloc_pointer &&
+               s == last_dealloc_size &&
+               a == last_dealloc_align;
+    }
+
+    bool checkDealloc(void* p, size_t s) const {
+        return p == last_dealloc_pointer &&
+               s == last_dealloc_size;
+    }
+
+    bool checkDeallocMatchesAlloc() const {
+        return last_dealloc_pointer == last_alloc_pointer &&
+               last_dealloc_size == last_alloc_size &&
+               last_dealloc_align == last_alloc_align;
+    }
+
+    void countIsEqual() {
+        ++is_equal_count;
+    }
+
+    bool checkIsEqualCalledEq(int n) const {
+        return is_equal_count == n;
+    }
+private:
+  DISALLOW_COPY(AllocController);
+};
+
+template <class T>
+class CountingAllocator
+{
+public:
+    typedef T value_type;
+    typedef T* pointer;
+    CountingAllocator() = delete;
+    explicit CountingAllocator(AllocController& PP) : P(&PP) {}
+
+    CountingAllocator(CountingAllocator const& other) : P(other.P) {
+        P->copy_constructed += 1;
+    }
+
+    CountingAllocator(CountingAllocator&& other) : P(other.P) {
+        P->move_constructed += 1;
+    }
+
+    template <class U>
+    CountingAllocator(CountingAllocator<U> const& other) TEST_NOEXCEPT : P(other.P) {
+        P->copy_constructed += 1;
+    }
+
+    template <class U>
+    CountingAllocator(CountingAllocator<U>&& other) TEST_NOEXCEPT : P(other.P) {
+        P->move_constructed += 1;
+    }
+
+    T* allocate(std::size_t n)
+    {
+        void* ret = ::operator new(n*sizeof(T));
+        P->countAlloc(ret, n*sizeof(T), alignof(T));
+        return static_cast<T*>(ret);
+    }
+
+    void deallocate(T* p, std::size_t n)
+    {
+        void* vp = static_cast<void*>(p);
+        P->countDealloc(vp, n*sizeof(T), alignof(T));
+        ::operator delete(vp);
+    }
+
+    AllocController& getController() const { return *P; }
+
+private:
+    template <class Tp> friend class CountingAllocator;
+    AllocController *P;
+};
+
+template <class T, class U>
+inline bool operator==(CountingAllocator<T> const& x,
+                       CountingAllocator<U> const& y) {
+    return &x.getController() == &y.getController();
+}
+
+template <class T, class U>
+inline bool operator!=(CountingAllocator<T> const& x,
+                       CountingAllocator<U> const& y) {
+    return !(x == y);
+}
+
+template <class T>
+class MinAlignedAllocator
+{
+public:
+    typedef T value_type;
+    typedef T* pointer;
+
+    MinAlignedAllocator() = delete;
+
+    explicit MinAlignedAllocator(AllocController& R) : P(&R) {}
+
+    MinAlignedAllocator(MinAlignedAllocator const& other) : P(other.P) {
+        P->copy_constructed += 1;
+    }
+
+    MinAlignedAllocator(MinAlignedAllocator&& other) : P(other.P) {
+        P->move_constructed += 1;
+    }
+
+    template <class U>
+    MinAlignedAllocator(MinAlignedAllocator<U> const& other) TEST_NOEXCEPT : P(other.P) {
+        P->copy_constructed += 1;
+    }
+
+    template <class U>
+    MinAlignedAllocator(MinAlignedAllocator<U>&& other) TEST_NOEXCEPT : P(other.P) {
+        P->move_constructed += 1;
+    }
+
+    T* allocate(std::size_t n) {
+        char* aligned_ptr = (char*)::operator new(alloc_size(n*sizeof(T)));
+        assert(is_max_aligned(aligned_ptr));
+
+        char* unaligned_ptr = aligned_ptr + alignof(T);
+        assert(is_min_aligned(unaligned_ptr));
+
+        P->countAlloc(unaligned_ptr, n * sizeof(T), alignof(T));
+
+        return ((T*)unaligned_ptr);
+    }
+
+    void deallocate(T* p, std::size_t n) {
+        assert(is_min_aligned(p));
+
+        char* aligned_ptr = ((char*)p) - alignof(T);
+        assert(is_max_aligned(aligned_ptr));
+
+        P->countDealloc(p, n*sizeof(T), alignof(T));
+
+        return ::operator delete(static_cast<void*>(aligned_ptr));
+    }
+
+    AllocController& getController() const { return *P; }
+
+private:
+    static const std::size_t BlockSize = alignof(std::max_align_t);
+
+    static std::size_t alloc_size(std::size_t s) {
+        std::size_t bytes = (s + BlockSize - 1) & ~(BlockSize - 1);
+        bytes += BlockSize;
+        assert(bytes % BlockSize == 0);
+        return bytes;
+    }
+
+    static bool is_max_aligned(void* p) {
+        return reinterpret_cast<std::uintptr_t>(p) % BlockSize == 0;
+    }
+
+    static bool is_min_aligned(void* p) {
+        if (alignof(T) == BlockSize) {
+            return is_max_aligned(p);
+        } else {
+            return reinterpret_cast<std::uintptr_t>(p) % BlockSize == alignof(T);
+        }
+    }
+
+    template <class Tp> friend class MinAlignedAllocator;
+    mutable AllocController *P;
+};
+
+
+template <class T, class U>
+inline bool operator==(MinAlignedAllocator<T> const& x,
+                       MinAlignedAllocator<U> const& y) {
+    return &x.getController() == &y.getController();
+}
+
+template <class T, class U>
+inline bool operator!=(MinAlignedAllocator<T> const& x,
+                       MinAlignedAllocator<U> const& y) {
+    return !(x == y);
+}
+
+template <class T>
+class NullAllocator
+{
+public:
+    typedef T value_type;
+    typedef T* pointer;
+    NullAllocator() = delete;
+    explicit NullAllocator(AllocController& PP) : P(&PP) {}
+
+    NullAllocator(NullAllocator const& other) : P(other.P) {
+        P->copy_constructed += 1;
+    }
+
+    NullAllocator(NullAllocator&& other) : P(other.P) {
+        P->move_constructed += 1;
+    }
+
+    template <class U>
+    NullAllocator(NullAllocator<U> const& other) TEST_NOEXCEPT : P(other.P) {
+        P->copy_constructed += 1;
+    }
+
+    template <class U>
+    NullAllocator(NullAllocator<U>&& other) TEST_NOEXCEPT : P(other.P) {
+        P->move_constructed += 1;
+    }
+
+    T* allocate(std::size_t n)
+    {
+        P->countAlloc(nullptr, n*sizeof(T), alignof(T));
+        return nullptr;
+    }
+
+    void deallocate(T* p, std::size_t n)
+    {
+        void* vp = static_cast<void*>(p);
+        P->countDealloc(vp, n*sizeof(T), alignof(T));
+    }
+
+    AllocController& getController() const { return *P; }
+
+private:
+    template <class Tp> friend class NullAllocator;
+    AllocController *P;
+};
+
+template <class T, class U>
+inline bool operator==(NullAllocator<T> const& x,
+                       NullAllocator<U> const& y) {
+    return &x.getController() == &y.getController();
+}
+
+template <class T, class U>
+inline bool operator!=(NullAllocator<T> const& x,
+                       NullAllocator<U> const& y) {
+    return !(x == y);
+}
+
+
+
+template <class ProviderT, int = 0>
+class TestResourceImp : public std::experimental::pmr::memory_resource
+{
+public:
+    static int resource_alive;
+    static int resource_constructed;
+    static int resource_destructed;
+
+    static void resetStatics() {
+        assert(resource_alive == 0);
+        resource_alive = 0;
+        resource_constructed = 0;
+        resource_destructed = 0;
+    }
+
+    using memory_resource = std::experimental::pmr::memory_resource;
+    using Provider = ProviderT;
+
+    int value;
+
+    explicit TestResourceImp(int val = 0) : value(val) {
+        ++resource_alive;
+        ++resource_constructed;
+    }
+
+    ~TestResourceImp() noexcept {
+        --resource_alive;
+        ++resource_destructed;
+    }
+
+    void reset() { C.reset(); P.reset(); }
+    AllocController& getController() { return C; }
+
+    bool checkAlloc(void* p, std::size_t s, std::size_t a) const
+      { return C.checkAlloc(p, s, a); }
+
+    bool checkDealloc(void* p, std::size_t s, std::size_t a) const
+      { return C.checkDealloc(p, s, a); }
+
+    bool checkIsEqualCalledEq(int n) const { return C.checkIsEqualCalledEq(n); }
+
+protected:
+    virtual void * do_allocate(std::size_t s, std::size_t a) {
+        if (C.throw_on_alloc) {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+            throw TestException{};
+#else
+            assert(false);
+#endif
+        }
+        void* ret = P.allocate(s, a);
+        C.countAlloc(ret, s, a);
+        return ret;
+    }
+
+    virtual void do_deallocate(void * p, std::size_t s, std::size_t a) {
+        C.countDealloc(p, s, a);
+        P.deallocate(p, s, a);
+    }
+
+    virtual bool do_is_equal(memory_resource const & other) const noexcept {
+        C.countIsEqual();
+        TestResourceImp const * o = dynamic_cast<TestResourceImp const *>(&other);
+        return o && o->value == value;
+    }
+private:
+    mutable AllocController C;
+    mutable Provider P;
+    DISALLOW_COPY(TestResourceImp);
+};
+
+template <class Provider, int N>
+int TestResourceImp<Provider, N>::resource_alive = 0;
+
+template <class Provider, int N>
+int TestResourceImp<Provider, N>::resource_constructed = 0;
+
+template <class Provider, int N>
+int TestResourceImp<Provider, N>::resource_destructed = 0;
+
+
+struct NullProvider {
+    NullProvider() {}
+    void* allocate(size_t, size_t) { return nullptr; }
+    void deallocate(void*, size_t, size_t) {}
+    void reset() {}
+private:
+    DISALLOW_COPY(NullProvider);
+};
+
+struct NewDeleteProvider {
+    NewDeleteProvider() {}
+    void* allocate(size_t s, size_t) { return ::operator new(s); }
+    void deallocate(void* p, size_t, size_t) { ::operator delete(p); }
+    void reset() {}
+private:
+    DISALLOW_COPY(NewDeleteProvider);
+};
+
+template <size_t Size = 4096 * 10> // 10 pages worth of memory.
+struct BufferProvider {
+    char buffer[Size];
+    void* next = &buffer;
+    size_t space = Size;
+
+    BufferProvider() {}
+
+    void* allocate(size_t s, size_t a) {
+        void* ret = std::align(s, a, next, space);
+        if (ret == nullptr) {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+            throw std::bad_alloc();
+#else
+            assert(false);
+#endif
+        }
+
+        return ret;
+    }
+
+    void deallocate(void*, size_t, size_t) {}
+
+    void reset() {
+        next = &buffer;
+        space = Size;
+    }
+private:
+    DISALLOW_COPY(BufferProvider);
+};
+
+using NullResource = TestResourceImp<NullProvider, 0>;
+using NewDeleteResource = TestResourceImp<NewDeleteProvider, 0>;
+using TestResource  = TestResourceImp<BufferProvider<>, 0>;
+using TestResource1 = TestResourceImp<BufferProvider<>, 1>;
+using TestResource2 = TestResourceImp<BufferProvider<>, 2>;
+
+
+#endif /* SUPPORT_TEST_MEMORY_RESOURCE_HPP */
diff --git a/test/support/type_id.h b/test/support/type_id.h
new file mode 100644
index 000000000000..309f0884e4a7
--- /dev/null
+++ b/test/support/type_id.h
@@ -0,0 +1,57 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+#ifndef SUPPORT_TYPE_ID_H
+#define SUPPORT_TYPE_ID_H
+
+#include <functional>
+#include <cassert>
+
+#include "test_macros.h"
+
+#if TEST_STD_VER < 11
+#error This header requires C++11 or greater
+#endif
+
+// TypeID - Represent a unique identifier for a type. TypeID allows equality
+// comparisons between different types.
+struct TypeID {
+  friend bool operator==(TypeID const& LHS, TypeID const& RHS)
+  {return LHS.m_id == RHS.m_id; }
+  friend bool operator!=(TypeID const& LHS, TypeID const& RHS)
+  {return LHS.m_id != RHS.m_id; }
+private:
+  explicit constexpr TypeID(const int* xid) : m_id(xid) {}
+
+  TypeID(const TypeID&) = delete;
+  TypeID& operator=(TypeID const&) = delete;
+
+  const int* const m_id;
+  template <class T> friend TypeID const& makeTypeID();
+
+};
+
+// makeTypeID - Return the TypeID for the specified type 'T'.
+template <class T>
+inline TypeID const& makeTypeID() {
+  static int dummy;
+  static const TypeID id(&dummy);
+  return id;
+}
+
+template <class ...Args>
+struct ArgumentListID {};
+
+// makeArgumentID - Create and return a unique identifier for a given set
+// of arguments.
+template <class ...Args>
+inline  TypeID const& makeArgumentID() {
+  return makeTypeID<ArgumentListID<Args...>>();
+}
+
+#endif // SUPPORT_TYPE_ID_H
diff --git a/test/support/uses_alloc_types.hpp b/test/support/uses_alloc_types.hpp
new file mode 100644
index 000000000000..834e57729a7a
--- /dev/null
+++ b/test/support/uses_alloc_types.hpp
@@ -0,0 +1,298 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef USES_ALLOC_TYPES_HPP
+#define USES_ALLOC_TYPES_HPP
+
+# include <experimental/memory_resource>
+# include <experimental/utility>
+# include <memory>
+# include <cassert>
+
+#include "test_memory_resource.hpp"
+#include "type_id.h"
+
+// There are two forms of uses-allocator construction:
+//   (1) UA_AllocArg: 'T(allocator_arg_t, Alloc const&, Args&&...)'
+//   (2) UA_AllocLast: 'T(Args&&..., Alloc const&)'
+// 'UA_None' represents non-uses allocator construction.
+enum class UsesAllocatorType {
+  UA_None = 0,
+  UA_AllocArg = 2,
+  UA_AllocLast = 4
+};
+constexpr UsesAllocatorType UA_None = UsesAllocatorType::UA_None;
+constexpr UsesAllocatorType UA_AllocArg = UsesAllocatorType::UA_AllocArg;
+constexpr UsesAllocatorType UA_AllocLast = UsesAllocatorType::UA_AllocLast;
+
+template <class Alloc, std::size_t N>
+class UsesAllocatorV1;
+    // Implements form (1) of uses-allocator construction from the specified
+    // 'Alloc' type and exactly 'N' additional arguments. It also provides
+    // non-uses allocator construction from 'N' arguments. This test type
+    // blows up when form (2) of uses-allocator is even considered.
+
+template <class Alloc, std::size_t N>
+class UsesAllocatorV2;
+    // Implements form (2) of uses-allocator construction from the specified
+    // 'Alloc' type and exactly 'N' additional arguments. It also provides
+    // non-uses allocator construction from 'N' arguments.
+
+template <class Alloc, std::size_t N>
+class UsesAllocatorV3;
+    // Implements both form (1) and (2) of uses-allocator construction from
+    // the specified 'Alloc' type and exactly 'N' additional arguments. It also
+    // provides non-uses allocator construction from 'N' arguments.
+
+template <class Alloc, std::size_t>
+class NotUsesAllocator;
+    // Implements both form (1) and (2) of uses-allocator construction from
+    // the specified 'Alloc' type and exactly 'N' additional arguments. It also
+    // provides non-uses allocator construction from 'N' arguments. However
+    // 'NotUsesAllocator' never provides a 'allocator_type' typedef so it is
+    // never automatically uses-allocator constructed.
+
+
+template <class ...ArgTypes, class TestType>
+bool checkConstruct(TestType& value, UsesAllocatorType form,
+                    typename TestType::CtorAlloc const& alloc)
+    // Check that 'value' was constructed using the specified 'form' of
+    // construction and with the specified 'ArgTypes...'. Additionally
+    // check that 'value' was constructed using the specified 'alloc'.
+{
+    if (form == UA_None) {
+        return value.template checkConstruct<ArgTypes&&...>(form);
+    } else {
+        return value.template checkConstruct<ArgTypes&&...>(form, alloc);
+    }
+}
+
+
+template <class ...ArgTypes, class TestType>
+bool checkConstruct(TestType& value, UsesAllocatorType form) {
+    return value.template checkConstruct<ArgTypes&&...>(form);
+}
+
+template <class TestType>
+bool checkConstructionEquiv(TestType& T, TestType& U)
+    // check that 'T' and 'U' where initialized in the exact same manner.
+{
+    return T.checkConstructEquiv(U);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+namespace detail {
+
+template <bool IsZero, size_t N, class ArgList, class ...Args>
+struct TakeNImp;
+
+template <class ArgList, class ...Args>
+struct TakeNImp<true, 0, ArgList, Args...> {
+  typedef ArgList type;
+};
+
+template <size_t N, class ...A1, class F, class ...R>
+struct TakeNImp<false, N, ArgumentListID<A1...>, F, R...>
+    : TakeNImp<N-1 == 0, N - 1, ArgumentListID<A1..., F>, R...> {};
+
+template <size_t N, class ...Args>
+struct TakeNArgs : TakeNImp<N == 0, N, ArgumentListID<>, Args...> {};
+
+template <class T>
+struct Identity { typedef T type; };
+
+template <class T>
+using IdentityT = typename Identity<T>::type;
+
+template <bool Value>
+using EnableIfB = typename std::enable_if<Value, bool>::type;
+
+} // end namespace detail
+
+using detail::EnableIfB;
+
+struct AllocLastTag {};
+
+template <class Alloc>
+struct UsesAllocatorTestBase {
+public:
+    using CtorAlloc = typename std::conditional<
+        std::is_same<Alloc, std::experimental::erased_type>::value,
+        std::experimental::pmr::memory_resource*,
+        Alloc
+    >::type;
+
+    template <class ...ArgTypes>
+    bool checkConstruct(UsesAllocatorType expectType) const {
+        return expectType == constructor_called &&
+               makeArgumentID<ArgTypes...>() == *args_id;
+    }
+
+    template <class ...ArgTypes>
+    bool checkConstruct(UsesAllocatorType expectType,
+                        CtorAlloc const& expectAlloc) const {
+        return expectType == constructor_called &&
+               makeArgumentID<ArgTypes...>() == *args_id &&
+               expectAlloc == allocator;
+    }
+
+    bool checkConstructEquiv(UsesAllocatorTestBase& O) const {
+        return constructor_called == O.constructor_called
+            && *args_id == *O.args_id
+            && allocator == O.allocator;
+    }
+
+protected:
+    explicit UsesAllocatorTestBase(const TypeID* aid)
+        : args_id(aid), constructor_called(UA_None), allocator()
+    {}
+
+    template <class ...Args>
+    UsesAllocatorTestBase(std::allocator_arg_t, CtorAlloc const& a, Args&&...)
+        : args_id(&makeArgumentID<Args&&...>()),
+          constructor_called(UA_AllocArg),
+          allocator(a)
+    {}
+
+    template <class ...Args, class ArgsIDL = detail::TakeNArgs<sizeof...(Args) - 1, Args&&...>>
+    UsesAllocatorTestBase(AllocLastTag, Args&&... args)
+        : args_id(&makeTypeID<typename ArgsIDL::type>()),
+          constructor_called(UA_AllocLast),
+          allocator(getAllocatorFromPack(
+            typename ArgsIDL::type{},
+            std::forward<Args>(args)...))
+    {
+    }
+
+private:
+    template <class ...LArgs, class ...Args>
+    static CtorAlloc getAllocatorFromPack(ArgumentListID<LArgs...>, Args&&... args) {
+        return getAllocatorFromPackImp<LArgs const&...>(args...);
+    }
+
+    template <class ...LArgs>
+    static CtorAlloc getAllocatorFromPackImp(
+        typename detail::Identity<LArgs>::type..., CtorAlloc const& alloc) {
+        return alloc;
+    }
+
+    const TypeID* args_id;
+    UsesAllocatorType constructor_called = UA_None;
+    CtorAlloc allocator;
+};
+
+template <class Alloc, size_t Arity>
+class UsesAllocatorV1 : public UsesAllocatorTestBase<Alloc>
+{
+public:
+    typedef Alloc allocator_type;
+
+    using Base = UsesAllocatorTestBase<Alloc>;
+    using CtorAlloc = typename Base::CtorAlloc;
+
+    UsesAllocatorV1() : Base(&makeArgumentID<>()) {}
+
+    // Non-Uses Allocator Ctor
+    template <class ...Args, EnableIfB<sizeof...(Args) == Arity> = false>
+    UsesAllocatorV1(Args&&... args) : Base(&makeArgumentID<Args&&...>()) {};
+
+    // Uses Allocator Arg Ctor
+    template <class ...Args>
+    UsesAllocatorV1(std::allocator_arg_t tag, CtorAlloc const & a, Args&&... args)
+        : Base(tag, a, std::forward<Args>(args)...)
+    { }
+
+    // BLOWS UP: Uses Allocator Last Ctor
+    template <class _First, class ...Args, EnableIfB<sizeof...(Args) == Arity> _Dummy = false>
+    constexpr UsesAllocatorV1(_First&& __first, Args&&... args)
+    {
+        static_assert(!std::is_same<_First, _First>::value, "");
+    }
+};
+
+
+template <class Alloc, size_t Arity>
+class UsesAllocatorV2 : public UsesAllocatorTestBase<Alloc>
+{
+public:
+    typedef Alloc allocator_type;
+
+    using Base = UsesAllocatorTestBase<Alloc>;
+    using CtorAlloc = typename Base::CtorAlloc;
+
+    UsesAllocatorV2() : Base(&makeArgumentID<>()) {}
+
+    // Non-Uses Allocator Ctor
+    template <class ...Args, EnableIfB<sizeof...(Args) == Arity> = false>
+    UsesAllocatorV2(Args&&... args) : Base(&makeArgumentID<Args&&...>()) {};
+
+    // Uses Allocator Last Ctor
+    template <class ...Args, EnableIfB<sizeof...(Args) == Arity + 1> = false>
+    UsesAllocatorV2(Args&&... args)
+        : Base(AllocLastTag{}, std::forward<Args>(args)...)
+    {}
+};
+
+template <class Alloc, size_t Arity>
+class UsesAllocatorV3 : public UsesAllocatorTestBase<Alloc>
+{
+public:
+    typedef Alloc allocator_type;
+
+    using Base = UsesAllocatorTestBase<Alloc>;
+    using CtorAlloc = typename Base::CtorAlloc;
+
+    UsesAllocatorV3() : Base(&makeArgumentID<>()) {}
+
+    // Non-Uses Allocator Ctor
+    template <class ...Args, EnableIfB<sizeof...(Args) == Arity> = false>
+    UsesAllocatorV3(Args&&... args) : Base(&makeArgumentID<Args&&...>()) {};
+
+    // Uses Allocator Arg Ctor
+    template <class ...Args>
+    UsesAllocatorV3(std::allocator_arg_t tag, CtorAlloc const& alloc, Args&&... args)
+        : Base(tag, alloc, std::forward<Args>(args)...)
+    {}
+
+    // Uses Allocator Last Ctor
+    template <class ...Args, EnableIfB<sizeof...(Args) == Arity + 1> = false>
+    UsesAllocatorV3(Args&&... args)
+        : Base(AllocLastTag{}, std::forward<Args>(args)...)
+    {}
+};
+
+template <class Alloc, size_t Arity>
+class NotUsesAllocator : public UsesAllocatorTestBase<Alloc>
+{
+public:
+    // no allocator_type typedef provided
+
+    using Base = UsesAllocatorTestBase<Alloc>;
+    using CtorAlloc = typename Base::CtorAlloc;
+
+    NotUsesAllocator() : Base(&makeArgumentID<>()) {}
+
+    // Non-Uses Allocator Ctor
+    template <class ...Args, EnableIfB<sizeof...(Args) == Arity> = false>
+    NotUsesAllocator(Args&&... args) : Base(&makeArgumentID<Args&&...>()) {};
+
+    // Uses Allocator Arg Ctor
+    template <class ...Args>
+    NotUsesAllocator(std::allocator_arg_t tag, CtorAlloc const& alloc, Args&&... args)
+        : Base(tag, alloc, std::forward<Args>(args)...)
+    {}
+
+    // Uses Allocator Last Ctor
+    template <class ...Args, EnableIfB<sizeof...(Args) == Arity + 1> = false>
+    NotUsesAllocator(Args&&... args)
+        : Base(AllocLastTag{}, std::forward<Args>(args)...)
+    {}
+};
+
+#endif /* USES_ALLOC_TYPES_HPP */
diff --git a/test/ubsan_blacklist.txt b/test/ubsan_blacklist.txt
new file mode 100644
index 000000000000..8331d7f41f63
--- /dev/null
+++ b/test/ubsan_blacklist.txt
@@ -0,0 +1 @@
+fun:*__hash_table*
diff --git a/www/cxx1z_status.html b/www/cxx1z_status.html
index 42bc3d76032a..dc6587a1d1fd 100644
--- a/www/cxx1z_status.html
+++ b/www/cxx1z_status.html
@@ -53,7 +53,7 @@
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3346.pdf">3346</a></td><td>LWG</td><td>Terminology for Container Element Requirements - Rev 1</td><td>Kona</td><td>Complete</td><td>3.4</td></tr>
 -->
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3911">N3911</a></td><td>LWG</td></td><td>TransformationTrait Alias <code>void_t</code>.</td><td>Urbana</td><td>Complete</td><td>3.6</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4089">N4089</a></td><td>LWG</td></td><td>Safe conversions in <code>unique_ptr&lt;T[]&gt;</code>.</td><td>Urbana</td><td></td><td></td></tr>
+	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4089">N4089</a></td><td>LWG</td></td><td>Safe conversions in <code>unique_ptr&lt;T[]&gt;</code>.</td><td>Urbana</td><td>In progress</td><td>3.9</td></tr>
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4169">N4169</a></td><td>LWG</td></td><td>A proposal to add invoke function template</td><td>Urbana</td><td>Complete</td><td>3.7</td></tr>
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4190">N4190</a></td></td><td>LWG</td><td>Removing auto_ptr, random_shuffle(), And Old <functional> Stuff.</td><td>Urbana</td><td></td><td></td></tr>
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4258">N4258</a></td><td>LWG</td></td><td>Cleaning-up noexcept in the Library.</td><td>Urbana</td><td>In progress</td><td>3.7</td></tr>
@@ -71,12 +71,56 @@
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4510">N4510</a></td><td>LWG</td></td><td>Minimal incomplete type support for standard containers, revision 4</td><td>Lenexa</td><td>Complete</td><td>3.6</td></tr>
   	<tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/P0004R1.html">P0004R1</a></td><td>LWG</td><td>Remove Deprecated iostreams aliases.</td><td>Kona</td><td>Complete</td><td>3.8</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/P0006R0.html">P0006R0</a></td><td>LWG</td><td>Adopt Type Traits Variable Templates for C++17.</td><td>Kona</td><td>Complete</td><td>3.8</td></tr>
+	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0006r0.html">P0006R0</a></td><td>LWG</td><td>Adopt Type Traits Variable Templates for C++17.</td><td>Kona</td><td>Complete</td><td>3.8</td></tr>
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/P0092R1.html">P0092R1</a></td><td>LWG</td><td>Polishing &lt;chrono&gt;</td><td>Kona</td><td>Complete</td><td>3.8</td></tr>
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/P0007R1.html">P0007R1</a></td><td>LWG</td><td>Constant View: A proposal for a <tt>std::as_const</tt> helper function template.</td><td>Kona</td><td>Complete</td><td>3.8</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/P0156R0.htm" >P0156R0</a></td><td>LWG</td><td>Variadic lock_guard(rev 3).</td><td>Kona</td><td></td><td></td></tr>
+	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0156r0.html" >P0156R0</a></td><td>LWG</td><td>Variadic lock_guard(rev 3).</td><td>Kona</td><td>Complete (ABI V2 Only)</td><td>3.9</td></tr>
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/P0074R0.html">P0074R0</a></td><td>LWG</td><td>Making <tt>std::owner_less</tt> more flexible</td><td>Kona</td><td>Complete</td><td>3.8</td></tr>
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/P0013R1.html">P0013R1</a></td><td>LWG</td><td>Logical type traits rev 2</td><td>Kona</td><td>Complete</td><td>3.8</td></tr>
+  	<tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
+	<tr><td><a href="http://wg21.link/P0024R2">P0024R2</a></td><td>LWG</td><td>The Parallelism TS Should be Standardized</td><td>Jacksonville</td><td></td><td></td></tr>
+	<tr><td><a href="http://wg21.link/P0226R1">P0226R1</a></td><td>LWG</td><td>Mathematical Special Functions for C++17</td><td>Jacksonville</td><td></td><td></td></tr>
+	<tr><td><a href="http://wg21.link/P0220R1">P0220R1</a></td><td>LWG</td><td>Adopt Library Fundamentals V1 TS Components for C++17</td><td>Jacksonville</td><td></td><td></td></tr>
+	<tr><td><a href="http://wg21.link/P0218R1">P0218R1</a></td><td>LWG</td><td>Adopt the File System TS for C++17</td><td>Jacksonville</td><td></td><td></td></tr>
+	<tr><td><a href="http://wg21.link/P0033R1">P0033R1</a></td><td>LWG</td><td>Re-enabling shared_from_this</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
+	<tr><td><a href="http://wg21.link/P0005R4">P0005R4</a></td><td>LWG</td><td>Adopt not_fn from Library Fundamentals 2 for C++17</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
+	<tr><td><a href="http://wg21.link/P0152R1">P0152R1</a></td><td>LWG</td><td>constexpr atomic::is_always_lock_free</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
+	<tr><td><a href="http://wg21.link/P0185R1">P0185R1</a></td><td>LWG</td><td>Adding [nothrow-]swappable traits</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
+	<tr><td><a href="http://wg21.link/P0253R1">P0253R1</a></td><td>LWG</td><td>Fixing a design mistake in the searchers interface</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
+	<tr><td><a href="http://wg21.link/P0025R0">P0025R0</a></td><td>LWG</td><td>An algorithm to "clamp" a value between a pair of boundary values</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
+	<tr><td><a href="http://wg21.link/P0154R1">P0154R1</a></td><td>LWG</td><td>constexpr std::hardware_{constructive,destructive}_interference_size</td><td>Jacksonville</td><td></td><td></td></tr>
+	<tr><td><a href="http://wg21.link/P0030R1">P0030R1</a></td><td>LWG</td><td>Proposal to Introduce a 3-Argument Overload to std::hypot</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
+	<tr><td><a href="http://wg21.link/P0031R0">P0031R0</a></td><td>LWG</td><td>A Proposal to Add Constexpr Modifiers to reverse_iterator, move_iterator, array and Range Access</td><td>Jacksonville</td><td></td><td></td></tr>
+	<tr><td><a href="http://wg21.link/P0272R1">P0272R1</a></td><td>LWG</td><td>Give <tt>std::string</tt> a non-const <tt>.data()</tt> member function</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
+	<tr><td><a href="http://wg21.link/P0077R2">P0077R2</a></td><td>LWG</td><td><tt>is_callable</tt>, the missing INVOKE related trait</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
+  	<tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
+	<tr><td><a href="http://wg21.link/p0032r3">p0032r3</a></td><td>LWG</td><td>Homogeneous interface for variant, any and optional</td><td>Oulu</td><td></td><td></td></tr>
+	<tr><td><a href="http://wg21.link/p0040r3">p0040r3</a></td><td>LWG</td><td>Extending memory management tools</td><td>Oulu</td><td></td><td></td></tr>
+	<tr><td><a href="http://wg21.link/p0063r3">p0063r3</a></td><td>LWG</td><td>C++17 should refer to C11 instead of C99</td><td>Oulu</td><td></td><td></td></tr>
+	<tr><td><a href="http://wg21.link/p0067r3">p0067r3</a></td><td>LWG</td><td>Elementary string conversions</td><td>Oulu</td><td>Postponed to Issaquah</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/p0083r3">p0083r3</a></td><td>LWG</td><td>Splicing Maps and Sets</td><td>Oulu</td><td></td><td></td></tr>
+	<tr><td><a href="http://wg21.link/p0084r2">p0084r2</a></td><td>LWG</td><td>Emplace Return Type</td><td>Oulu</td><td></td><td></td></tr>
+	<tr><td><a href="http://wg21.link/p0088r3">p0088r3</a></td><td>LWG</td><td>Variant: a type-safe union for C++17</td><td>Oulu</td><td></td><td></td></tr>
+	<tr><td><a href="http://wg21.link/p0163r0">p0163r0</a></td><td>LWG</td><td>shared_ptr::weak_type</td><td>Oulu</td><td>Complete</td><td>3.9</td></tr>
+	<tr><td><a href="http://wg21.link/p0174r2">p0174r2</a></td><td>LWG</td><td>Deprecating Vestigial Library Parts in C++17</td><td>Oulu</td><td></td><td></td></tr>
+	<tr><td><a href="http://wg21.link/p0175r1">p0175r1</a></td><td>LWG</td><td>Synopses for the C library</td><td>Oulu</td><td></td><td></td></tr>
+	<tr><td><a href="http://wg21.link/p0180r2">p0180r2</a></td><td>LWG</td><td>Reserve a New Library Namespace for Future Standardization</td><td>Oulu</td><td></td><td></td></tr>
+	<tr><td><a href="http://wg21.link/p0181r1">p0181r1</a></td><td>LWG</td><td>Ordered by Default</td><td>Oulu</td><td></td><td></td></tr>
+	<tr><td><a href="http://wg21.link/p0209r2">p0209r2</a></td><td>LWG</td><td>make_from_tuple: apply for construction</td><td>Oulu</td><td>Complete</td><td>3.9</td></tr>
+	<tr><td><a href="http://wg21.link/p0219r1">p0219r1</a></td><td>LWG</td><td>Relative Paths for Filesystem</td><td>Oulu</td><td></td><td></td></tr>
+	<tr><td><a href="http://wg21.link/p0254r2">p0254r2</a></td><td>LWG</td><td>Integrating std::string_view and std::string</td><td>Oulu</td><td></td><td></td></tr>
+	<tr><td><a href="http://wg21.link/p0258r2">p0258r2</a></td><td>LWG</td><td>has_unique_object_representations</td><td>Oulu</td><td></td><td></td></tr>
+	<tr><td><a href="http://wg21.link/p0295r0">p0295r0</a></td><td>LWG</td><td>Adopt Selected Library Fundamentals V2 Components for C++17</td><td>Oulu</td><td></td><td></td></tr>
+	<tr><td><a href="http://wg21.link/p0302r1">p0302r1</a></td><td>LWG</td><td>Removing Allocator Support in std::function</td><td>Oulu</td><td></td><td></td></tr>
+	<tr><td><a href="http://wg21.link/p0307r2">p0307r2</a></td><td>LWG</td><td>Making Optional Greater Equal Again</td><td>Oulu</td><td></td><td></td></tr>
+	<tr><td><a href="http://wg21.link/p0336r1">p0336r1</a></td><td>LWG</td><td>Better Names for Parallel Execution Policies in C++17</td><td>Oulu</td><td></td><td></td></tr>
+	<tr><td><a href="http://wg21.link/p0337r0">p0337r0</a></td><td>LWG</td><td>Delete operator= for polymorphic_allocator</td><td>Oulu</td><td></td><td></td></tr>
+	<tr><td><a href="http://wg21.link/p0346r1">p0346r1</a></td><td>LWG</td><td>A &lt;random&gt; Nomenclature Tweak</td><td>Oulu</td><td></td><td></td></tr>
+	<tr><td><a href="http://wg21.link/p0358r1">p0358r1</a></td><td>LWG</td><td>Fixes for not_fn</td><td>Oulu</td><td></td><td></td></tr>
+	<tr><td><a href="http://wg21.link/p0371r1">p0371r1</a></td><td>LWG</td><td>Temporarily discourage memory_order_consume</td><td>Oulu</td><td></td><td></td></tr>
+	<tr><td><a href="http://wg21.link/p0392r0">p0392r0</a></td><td>LWG</td><td>Adapting string_view by filesystem paths</td><td>Oulu</td><td></td><td></td></tr>
+	<tr><td><a href="http://wg21.link/p0393r3">p0393r3</a></td><td>LWG</td><td>Making Variant Greater Equal</td><td>Oulu</td><td></td><td></td></tr>
+	<tr><td><a href="http://wg21.link/P0394r4">P0394r4</a></td><td>LWG</td><td>Hotel Parallelifornia: terminate() for Parallel Algorithms Exception Handling</td><td>Oulu</td><td></td><td></td></tr>
 <!--  	<tr><td></td><td></td><td></td><td></td><td></td><td></td></tr> -->
   </table>
 
@@ -84,115 +128,196 @@
 <!--   <I>Note: "NAD" means that the issue was deemed "Not a defect"</I> -->
   <table id="issues" border="1">
 	<tr><th>Issue #</th><th>Issue Name</th><th>Meeting</th><th>Status</th></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2016">2016</a></td><td>Allocators must be no-throw swappable</td><td>Urbana</td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2376">2118</td><td><code>unique_ptr</code> for array does not support cv qualification conversion of actual argument</td><td>Urbana</td><td>Will be resolved by N4089</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2170">2170</a></td><td>Aggregates cannot be <code>DefaultConstructible</code></td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2308">2308</td><td>Clarify container destructor requirements w.r.t. <code>std::array</code></td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2340">2340</a></td><td>Replacement allocation functions declared as inline</td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2354">2354</a></td><td>Unnecessary copying when inserting into maps with braced-init syntax</td><td>Urbana</td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2377">2377</a></td><td><code>std::align</code> requirements overly strict</td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2396">2396</a></td><td><code>underlying_type</code> doesn't say what to do for an incomplete enumeration type</td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2399">2399</a></td><td><code>shared_ptr</code>'s constructor from <code>unique_ptr</code> should be constrained</td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2400">2400</a></td><td><code>shared_ptr</code>'s <code>get_deleter()</code> should use <code>addressof()</code></td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2401">2401</a></td><td><code>std::function</code> needs more noexcept</td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2404">2404</a></td><td><code>mismatch()</code>'s complexity needs to be updated</td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2408">2408</a></td><td>SFINAE-friendly <code>common_type</code> / <code>iterator_traits</code> is missing in C++14</td><td>Urbana</td><td><code>common_type</code> is waiting on <a href="http://cplusplus.github.io/LWG/lwg-defects.html#2465">LWG#2465</a></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2016">2016</a></td><td>Allocators must be no-throw swappable</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2376">2118</td><td><code>unique_ptr</code> for array does not support cv qualification conversion of actual argument</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2170">2170</a></td><td>Aggregates cannot be <code>DefaultConstructible</code></td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2308">2308</td><td>Clarify container destructor requirements w.r.t. <code>std::array</code></td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2340">2340</a></td><td>Replacement allocation functions declared as inline</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2354">2354</a></td><td>Unnecessary copying when inserting into maps with braced-init syntax</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2377">2377</a></td><td><code>std::align</code> requirements overly strict</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2396">2396</a></td><td><code>underlying_type</code> doesn't say what to do for an incomplete enumeration type</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2399">2399</a></td><td><code>shared_ptr</code>'s constructor from <code>unique_ptr</code> should be constrained</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2400">2400</a></td><td><code>shared_ptr</code>'s <code>get_deleter()</code> should use <code>addressof()</code></td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2401">2401</a></td><td><code>std::function</code> needs more noexcept</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2404">2404</a></td><td><code>mismatch()</code>'s complexity needs to be updated</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2408">2408</a></td><td>SFINAE-friendly <code>common_type</code> / <code>iterator_traits</code> is missing in C++14</td><td>Urbana</td><td><code>common_type</code> is waiting on <a href="http://wg21.link/LWG2465">LWG#2465</a></td></tr>
+ 	<tr><td></td><td></td><td></td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2106">2106</td><td><code>move_iterator</code> wrapping iterators returning prvalues</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2129">2129</td><td>User specializations of <code>std::initializer_list</code></td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2212">2212</td><td><code>tuple_size</code> for <code>const pair</code> request <tuple> header</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2217">2217</td><td><code>operator==(sub_match, string)</code> slices on embedded '\0's</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2230">2230</td><td>"see below" for <code>initializer_list</code> constructors of unordered containers</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2233">2233</td><td><code>bad_function_call::what()</code> unhelpful</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2266">2266</td><td><code>vector</code> and <code>deque</code> have incorrect insert requirements</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2325">2325</td><td><code>minmax_element()</code>'s behavior differing from <code>max_element()</code>'s should be noted</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2361">2361</td><td>Apply 2299 resolution throughout library</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2365">2365</td><td>Missing noexcept in <code>shared_ptr::shared_ptr(nullptr_t)</code></td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2376">2376</td><td><code>bad_weak_ptr::what()</code> overspecified</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2387">2387</td><td>More nested types that must be accessible and unambiguous</td><td>Urbana</td><td>Complete</td></tr>
+ 	<tr><td></td><td></td><td></td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2059">2059</td><td>C++0x ambiguity problem with map::erase</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2063">2063</td><td>Contradictory requirements for string move assignment</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2076">2076</td><td>Bad CopyConstructible requirement in set constructors</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2160">2160</td><td>Unintended destruction ordering-specification of resize</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2168">2168</td><td>Inconsistent specification of uniform_real_distribution constructor</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2239">2239</td><td>min/max/minmax requirements</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2364">2364</td><td>deque and vector pop_back don't specify iterator invalidation requirements</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2369">2369</td><td>constexpr max(initializer_list) vs max_element</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2378">2378</td><td>Behaviour of standard exception types</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2403">2403</td><td>stof() should call strtof() and wcstof()</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2406">2406</td><td>negative_binomial_distribution should reject p == 1</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2407">2407</td><td>packaged_task(allocator_arg_t, const Allocator&, F&&) should neither be constrained nor explicit</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2411">2411</td><td>shared_ptr is only contextually convertible to bool</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2415">2415</td><td>Inconsistency between unique_ptr and shared_ptr</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2420">2420</td><td>function<void(ArgTypes...)> does not discard the return value of the target object</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2425">2425</td><td>operator delete(void*, size_t) doesn't invalidate pointers sufficiently</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2427">2427</td><td>Container adaptors as sequence containers, redux</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2428">2428</td><td>"External declaration" used without being defined</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2433">2433</td><td>uninitialized_copy()/etc. should tolerate overloaded operator&</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2434">2434</td><td>shared_ptr::use_count() is efficient</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2437">2437</td><td>iterator_traits::reference can and can't be void</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2438">2438</td><td>std::iterator inheritance shouldn't be mandated</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2439">2439</td><td>unique_copy() sometimes can't fall back to reading its output</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2440">2440</td><td>seed_seq::size() should be noexcept</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2442">2442</td><td>call_once() shouldn't DECAY_COPY()</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2448">2448</td><td>Non-normative Container destructor specification</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2454">2454</td><td>Add raw_storage_iterator::base() member</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2455">2455</td><td>Allocator default construction should be allowed to throw</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2458">2458</td><td>N3778 and new library deallocation signatures</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2459">2459</td><td>std::polar should require a non-negative rho</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2464">2464</td><td>try_emplace and insert_or_assign misspecified</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2467">2467</td><td>is_always_equal has slightly inconsistent default</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2470">2470</td><td>Allocator's destroy function should be allowed to fail to instantiate</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2482">2482</td><td>[c.strings] Table 73 mentions nonexistent functions</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2488">2488</td><td>Placeholders should be allowed and encouraged to be constexpr</td><td>Lenexa</td><td>Complete</td></tr>
  	<tr><td></td><td></td><td></td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2106">2106</td><td><code>move_iterator</code> wrapping iterators returning prvalues</td><td>Urbana</td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2129">2129</td><td>User specializations of <code>std::initializer_list</code></td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2212">2212</td><td><code>tuple_size</code> for <code>const pair</code> request <tuple> header</td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2217">2217</td><td><code>operator==(sub_match, string)</code> slices on embedded '\0's</td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2230">2230</td><td>"see below" for <code>initializer_list</code> constructors of unordered containers</td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2233">2233</td><td><code>bad_function_call::what()</code> unhelpful</td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2266">2266</td><td><code>vector</code> and <code>deque</code> have incorrect insert requirements</td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2325">2325</td><td><code>minmax_element()</code>'s behavior differing from <code>max_element()</code>'s should be noted</td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2361">2361</td><td>Apply 2299 resolution throughout library</td><td>Urbana</td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2365">2365</td><td>Missing noexcept in <code>shared_ptr::shared_ptr(nullptr_t)</code></td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2376">2376</td><td><code>bad_weak_ptr::what()</code> overspecified</td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2387">2387</td><td>More nested types that must be accessible and unambiguous</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG1169">1169</a></td><td><tt>num_get</tt> not fully compatible with <tt>strto*</tt></td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2072">2072</a></td><td>Unclear wording about capacity of temporary buffers</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2101">2101</a></td><td>Some transformation types can produce impossible types</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2111">2111</a></td><td>Which <tt>unexpected</tt>&#47;<tt>terminate</tt> handler is called from the exception handling runtime?</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2119">2119</a></td><td>Missing <tt>hash</tt> specializations for extended integer types</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2127">2127</a></td><td>Move-construction with <tt>raw_storage_iterator</tt></td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2133">2133</a></td><td>Attitude to overloaded comma for iterators</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2156">2156</a></td><td>Unordered containers' <tt>reserve(n)</tt> reserves for <tt>n-1</tt> elements</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2218">2218</a></td><td>Unclear how containers use <tt>allocator_traits::construct()</tt></td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2219">2219</a></td><td><tt><i>INVOKE</i></tt>-ing a pointer to member with a <tt>reference_wrapper</tt> as the object expression</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2224">2224</a></td><td>Ambiguous status of access to non-live objects</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2234">2234</a></td><td><tt>assert()</tt> should allow usage in constant expressions</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2244">2244</a></td><td>Issue on <tt>basic_istream::seekg</tt></td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2250">2250</a></td><td>Follow-up On Library Issue 2207</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2259">2259</a></td><td>Issues in 17.6.5.5 rules for member functions</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2273">2273</a></td><td><tt>regex_match</tt> ambiguity</td><td>Kona</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2336">2336</a></td><td><tt>is_trivially_constructible/is_trivially_assignable</tt> traits are always false</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2353">2353</a></td><td><tt>std::next</tt> is over-constrained</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2367">2367</a></td><td><tt>pair</tt> and <tt>tuple</tt> are not correctly implemented for <tt>is_constructible</tt> with no args</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2380">2380</a></td><td>May <tt>&lt;cstdlib&gt;</tt> provide <tt>long ::abs(long)</tt> and <tt>long long ::abs(long long)</tt>?</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2384">2384</a></td><td>Allocator's <tt>deallocate</tt> function needs better specification</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2385">2385</a></td><td><tt>function::assign</tt> allocator argument doesn't make sense</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2435">2435</a></td><td><tt>reference_wrapper::operator()</tt>'s Remark should be deleted</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2447">2447</a></td><td>Allocators and <tt>volatile</tt>-qualified value types</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2462">2462</a></td><td><tt>std::ios_base::failure</tt> is overspecified</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2466">2466</a></td><td><tt>allocator_traits::max_size()</tt> default behavior is incorrect</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2469">2469</a></td><td>Wrong specification of Requires clause of <tt>operator[]</tt> for <tt>map</tt> and <tt>unordered_map</tt></td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2473">2473</a></td><td><tt>basic_filebuf</tt>'s relation to C <tt>FILE</tt> semantics</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2476">2476</a></td><td><tt>scoped_allocator_adaptor</tt> is not assignable</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2477">2477</a></td><td>Inconsistency of wordings in <tt>std::vector::erase()</tt> and <tt>std::deque::erase()</tt></td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2483">2483</a></td><td><tt>throw_with_nested()</tt> should use <tt>is_final</tt></td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2484">2484</a></td><td><tt>rethrow_if_nested()</tt> is doubly unimplementable</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2485">2485</a></td><td><tt>get()</tt> should be overloaded for <tt>const tuple&amp;&amp;</tt></td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2486">2486</a></td><td><tt>mem_fn()</tt> should be required to use perfect forwarding</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2487">2487</a></td><td><tt>bind()</tt> should be <tt>const</tt>-overloaded, not <i>cv</i>-overloaded</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2489">2489</a></td><td><tt>mem_fn()</tt> should be <tt>noexcept</tt></td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2492">2492</a></td><td>Clarify requirements for <tt>comp</tt></td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2495">2495</a></td><td>There is no such thing as an Exception Safety element</td><td>Kona</td><td>Complete</td></tr>
  	<tr><td></td><td></td><td></td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2059">2059</td><td>C++0x ambiguity problem with map::erase</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2063">2063</td><td>Contradictory requirements for string move assignment</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2076">2076</td><td>Bad CopyConstructible requirement in set constructors</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2160">2160</td><td>Unintended destruction ordering-specification of resize</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2168">2168</td><td>Inconsistent specification of uniform_real_distribution constructor</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2239">2239</td><td>min/max/minmax requirements</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2364">2364</td><td>deque and vector pop_back don't specify iterator invalidation requirements</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2369">2369</td><td>constexpr max(initializer_list) vs max_element</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2378">2378</td><td>Behaviour of standard exception types</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2403">2403</td><td>stof() should call strtof() and wcstof()</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2406">2406</td><td>negative_binomial_distribution should reject p == 1</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2407">2407</td><td>packaged_task(allocator_arg_t, const Allocator&, F&&) should neither be constrained nor explicit</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2411">2411</td><td>shared_ptr is only contextually convertible to bool</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2415">2415</td><td>Inconsistency between unique_ptr and shared_ptr</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2420">2420</td><td>function<void(ArgTypes...)> does not discard the return value of the target object</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2425">2425</td><td>operator delete(void*, size_t) doesn't invalidate pointers sufficiently</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2427">2427</td><td>Container adaptors as sequence containers, redux</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2428">2428</td><td>"External declaration" used without being defined</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2433">2433</td><td>uninitialized_copy()/etc. should tolerate overloaded operator&</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2434">2434</td><td>shared_ptr::use_count() is efficient</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2437">2437</td><td>iterator_traits::reference can and can't be void</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2438">2438</td><td>std::iterator inheritance shouldn't be mandated</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2439">2439</td><td>unique_copy() sometimes can't fall back to reading its output</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2440">2440</td><td>seed_seq::size() should be noexcept</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2442">2442</td><td>call_once() shouldn't DECAY_COPY()</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2448">2448</td><td>Non-normative Container destructor specification</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2454">2454</td><td>Add raw_storage_iterator::base() member</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2455">2455</td><td>Allocator default construction should be allowed to throw</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2458">2458</td><td>N3778 and new library deallocation signatures</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2459">2459</td><td>std::polar should require a non-negative rho</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2464">2464</td><td>try_emplace and insert_or_assign misspecified</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2467">2467</td><td>is_always_equal has slightly inconsistent default</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2470">2470</td><td>Allocator's destroy function should be allowed to fail to instantiate</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2482">2482</td><td>[c.strings] Table 73 mentions nonexistent functions</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2488">2488</td><td>Placeholders should be allowed and encouraged to be constexpr</td><td>Lenexa</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2192">2192</a></td><td>Validity and return type of <tt>std::abs(0u)</tt> is unclear</td><td>Jacksonville</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2276">2276</a></td><td>Missing requirement on <tt>std::promise::set_exception</tt></td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2296">2296</a></td><td><tt>std::addressof</tt> should be <tt>constexpr</td><td>Jacksonville</td><td>Complete (Clang Only)</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2450">2450</a></td><td><tt>(greater|less|greater_equal|less_equal)&lt;void&gt;</tt> do not yield a total order for pointers</td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2520">2520</a></td><td>N4089 broke initializing <tt>unique_ptr&lt;T[]&gt;</tt> from a <tt>nullptr</tt></td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2522">2522</a></td><td>[fund.ts.v2] Contradiction in <tt>set_default_resource</tt> specification</td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2523">2523</a></td><td><tt>std::promise</tt> synopsis shows two <tt>set_value_at_thread_exit()</tt>'s for no apparent reason</td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2537">2537</a></td><td>Constructors for <code>priority_queue</code> taking allocators should call <code>make_heap</code></td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2539">2539</a></td><td>[fund.ts.v2] <tt>invocation_trait</tt> definition definition doesn't work for surrogate call functions</td><td>Jacksonville</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2545">2545</a></td><td>Simplify wording for <tt>bind</tt> without explicitly specified return type</td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2557">2557</a></td><td>Logical operator traits are broken in the zero-argument case</td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2558">2558</a></td><td>[fund.ts.v2] Logical operator traits are broken in the zero-argument case</td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2559">2559</a></td><td>Error in LWG 2234's resolution</td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2560">2560</a></td><td><tt>is_constructible</tt> underspecified when applied to a function type</td><td>Jacksonville</td><td>Broken in 3.6; See r261653.</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2565">2565</a></td><td><tt>std::function</tt>'s move constructor should guarantee nothrow for <tt>reference_wrapper</tt>s and function pointers</td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2566">2566</a></td><td>Requirements on the first template parameter of container adaptors</td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2571">2571</a></td><td>&sect;[map.modifiers]/2 imposes nonsensical requirement on <tt>insert(InputIterator, InputIterator)</tt></td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2572">2572</a></td><td>The remarks for <tt>shared_ptr::operator*</tt> should apply to <i>cv</i>-qualified <tt>void</tt> as well</td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2574">2574</a></td><td>[fund.ts.v2] <tt>std::experimental::function::operator=(F&amp;&amp;)</tt> should be constrained</td><td>Jacksonville</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2575">2575</a></td><td>[fund.ts.v2] <tt>experimental::function::assign</tt> should be removed</td><td>Jacksonville</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2576">2576</a></td><td><tt>istream_iterator</tt> and <tt>ostream_iterator</tt> should use <tt>std::addressof</tt></td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2577">2577</a></td><td><tt>{shared,unique}_lock</tt> should use <tt>std::addressof</tt></td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2579">2579</a></td><td>Inconsistency wrt Allocators in <tt>basic_string</tt> assignment vs. <tt>basic_string::assign</tt></td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2581">2581</a></td><td>Specialization of <tt>&lt;type_traits&gt;</tt> variable templates should be prohibited</td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2582">2582</a></td><td>&sect;[res.on.functions]/2's prohibition against incomplete types shouldn't apply to type traits</td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2583">2583</a></td><td>There is no way to supply an allocator for <tt>basic_string(str, pos)</tt></td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2585">2585</a></td><td><tt>forward_list::resize(size_type, const value_type&amp;)</tt> effects incorrect</td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2586">2586</a></td><td>Wrong value category used in <tt>scoped_allocator_adaptor::construct()</tt></td><td>Jacksonville</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2590">2590</a></td><td>Aggregate initialization for <tt>std::array</tt></td><td>Jacksonville</td><td>Complete</td></tr>
  	<tr><td></td><td></td><td></td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#1169">1169</a></td><td><tt>num_get</tt> not fully compatible with <tt>strto*</tt></td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2072">2072</a></td><td>Unclear wording about capacity of temporary buffers</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2101">2101</a></td><td>Some transformation types can produce impossible types</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2111">2111</a></td><td>Which <tt>unexpected</tt>&#47;<tt>terminate</tt> handler is called from the exception handling runtime?</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2119">2119</a></td><td>Missing <tt>hash</tt> specializations for extended integer types</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2127">2127</a></td><td>Move-construction with <tt>raw_storage_iterator</tt></td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2133">2133</a></td><td>Attitude to overloaded comma for iterators</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2156">2156</a></td><td>Unordered containers' <tt>reserve(n)</tt> reserves for <tt>n-1</tt> elements</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2218">2218</a></td><td>Unclear how containers use <tt>allocator_traits::construct()</tt></td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2219">2219</a></td><td><tt><i>INVOKE</i></tt>-ing a pointer to member with a <tt>reference_wrapper</tt> as the object expression</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2224">2224</a></td><td>Ambiguous status of access to non-live objects</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2234">2234</a></td><td><tt>assert()</tt> should allow usage in constant expressions</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2244">2244</a></td><td>Issue on <tt>basic_istream::seekg</tt></td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2250">2250</a></td><td>Follow-up On Library Issue 2207</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2259">2259</a></td><td>Issues in 17.6.5.5 rules for member functions</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2273">2273</a></td><td><tt>regex_match</tt> ambiguity</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2336">2336</a></td><td><tt>is_trivially_constructible/is_trivially_assignable</tt> traits are always false</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2353">2353</a></td><td><tt>std::next</tt> is over-constrained</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2367">2367</a></td><td><tt>pair</tt> and <tt>tuple</tt> are not correctly implemented for <tt>is_constructible</tt> with no args</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2380">2380</a></td><td>May <tt>&lt;cstdlib&gt;</tt> provide <tt>long ::abs(long)</tt> and <tt>long long ::abs(long long)</tt>?</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2384">2384</a></td><td>Allocator's <tt>deallocate</tt> function needs better specification</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2385">2385</a></td><td><tt>function::assign</tt> allocator argument doesn't make sense</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2435">2435</a></td><td><tt>reference_wrapper::operator()</tt>'s Remark should be deleted</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2447">2447</a></td><td>Allocators and <tt>volatile</tt>-qualified value types</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2462">2462</a></td><td><tt>std::ios_base::failure</tt> is overspecified</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2466">2466</a></td><td><tt>allocator_traits::max_size()</tt> default behavior is incorrect</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2469">2469</a></td><td>Wrong specification of Requires clause of <tt>operator[]</tt> for <tt>map</tt> and <tt>unordered_map</tt></td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2473">2473</a></td><td><tt>basic_filebuf</tt>'s relation to C <tt>FILE</tt> semantics</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2476">2476</a></td><td><tt>scoped_allocator_adaptor</tt> is not assignable</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2477">2477</a></td><td>Inconsistency of wordings in <tt>std::vector::erase()</tt> and <tt>std::deque::erase()</tt></td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2483">2483</a></td><td><tt>throw_with_nested()</tt> should use <tt>is_final</tt></td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2484">2484</a></td><td><tt>rethrow_if_nested()</tt> is doubly unimplementable</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2485">2485</a></td><td><tt>get()</tt> should be overloaded for <tt>const tuple&amp;&amp;</tt></td><td>Kona</td><td>Completed</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2486">2486</a></td><td><tt>mem_fn()</tt> should be required to use perfect forwarding</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2487">2487</a></td><td><tt>bind()</tt> should be <tt>const</tt>-overloaded, not <i>cv</i>-overloaded</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2489">2489</a></td><td><tt>mem_fn()</tt> should be <tt>noexcept</tt></td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2492">2492</a></td><td>Clarify requirements for <tt>comp</tt></td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2495">2495</a></td><td>There is no such thing as an Exception Safety element</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2181">2181</a></td><td>Exceptions from seed sequence operations</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2309">2309</a></td><td>mutex::lock() should not throw device_or_resource_busy</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2310">2310</a></td><td>Public exposition only member in std::array</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2312">2312</a></td><td>tuple's constructor constraints need to be phrased more precisely</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2328">2328</a></td><td>Rvalue stream extraction should use perfect forwarding</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2393">2393</a></td><td>std::function's Callable definition is broken</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2422">2422</a></td><td>std::numeric_limits&lt;T&gt;::is_modulo description: "most machines" errata</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2426">2426</a></td><td>Issue about compare_exchange</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2436">2436</a></td><td>Comparators for associative containers should always be CopyConstructible</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2441">2441</a></td><td>Exact-width atomic typedefs should be provided</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2451">2451</a></td><td>[fund.ts.v2] optional should 'forward' T's implicit conversions</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2509">2509</a></td><td>[fund.ts.v2] any_cast doesn't work with rvalue reference targets and cannot move with a value target</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2516">2516</a></td><td>[fund.ts.v2] Public "exposition only" members in observer_ptr</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2542">2542</a></td><td>Missing const requirements for associative containers</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2549">2549</a></td><td>Tuple EXPLICIT constructor templates that take tuple parameters end up taking references to temporaries and will create dangling references</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2550">2550</a></td><td>Wording of unordered container's clear() method complexity</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2551">2551</a></td><td>[fund.ts.v2] "Exception safety" cleanup in library fundamentals required</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2555">2555</a></td><td>[fund.ts.v2] No handling for over-aligned types in optional</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2573">2573</a></td><td>[fund.ts.v2] std::hash&lt;std::experimental::shared_ptr&gt; does not work for arrays</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2596">2596</a></td><td>vector::data() should use addressof</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2667">2667</a></td><td>path::root_directory() description is confusing</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2669">2669</a></td><td>recursive_directory_iterator effects refers to non-existent functions</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2670">2670</a></td><td>system_complete refers to undefined variable 'base'</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2671">2671</a></td><td>Errors in Copy</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2673">2673</a></td><td>status() effects cannot be implemented as specified</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2674">2674</a></td><td>Bidirectional iterator requirement on path::iterator is very expensive</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2683">2683</a></td><td>filesystem::copy() says "no effects"</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2684">2684</a></td><td>priority_queue lacking comparator typedef</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2685">2685</a></td><td>shared_ptr deleters must not throw on move construction</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2687">2687</a></td><td>{inclusive,exclusive}_scan misspecified</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2688">2688</a></td><td>clamp misses preconditions and has extraneous condition on result</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2689">2689</a></td><td>Parallel versions of std::copy and std::move shouldn't be in order</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2698">2698</a></td><td>Effect of assign() on iterators/pointers/references</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2704">2704</a></td><td>recursive_directory_iterator's members should require '*this is dereferenceable'</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2706">2706</a></td><td>Error reporting for recursive_directory_iterator::pop() is under-specified</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2707">2707</a></td><td>path construction and assignment should have "string_type&&" overloads</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2709">2709</a></td><td>offsetof is unnecessarily imprecise</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2710">2710</a></td><td>"Effects: Equivalent to ..." doesn't count "Synchronization:" as determined semantics</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2711">2711</a></td><td>path is convertible from approximately everything under the sun</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2716">2716</a></td><td>Specification of shuffle and sample disallows lvalue URNGs</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2718">2718</a></td><td>Parallelism bug in [algorithms.parallel.exec] p2</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2719">2719</a></td><td>permissions function should not be noexcept due to narrow contract</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2720">2720</a></td><td>permissions function incorrectly specified for symlinks</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2721">2721</a></td><td>remove_all has incorrect post conditions</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2723">2723</a></td><td>Do directory_iterator and recursive_directory_iterator become the end iterator upon error?</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2724">2724</a></td><td>The protected virtual member functions of memory_resource should be private</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2725">2725</a></td><td>filesystem::exists(const path&, error_code&) error reporting</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2726">2726</a></td><td>[recursive_]directory_iterator::increment(error_code&) is underspecified</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2727">2727</a></td><td>Parallel algorithms with constexpr specifier</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2728">2728</a></td><td>status(p).permissions() and symlink_status(p).permissions() are not specified</td><td>Oulu</td><td>Complete</td></tr>
 
 <!--
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#1214">1214</a></td><td>Insufficient/inconsistent key immutability requirements for associative containers</td><td>Urbana</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG1214">1214</a></td><td>Insufficient/inconsistent key immutability requirements for associative containers</td><td>Urbana</td><td></td></tr>
 -->
 <!-- 	<tr><td></td><td></td><td></td><td></td></tr> -->
   </table>
 
-  <p>Last Updated: 5-Oct-2015</p>
+  <p>Last Updated: 12-Jul-2016</p>
 </div>
 </body>
 </html>
diff --git a/www/index.html b/www/index.html
index 821f25d7e04f..70cf5b60155e 100644
--- a/www/index.html
+++ b/www/index.html
@@ -166,96 +166,18 @@
   <p>First please review our
      <a href="http://llvm.org/docs/DeveloperPolicy.html">Developer's Policy</a>.
 
-  <p>
-     On Mac OS 10.7 (Lion) and later, the easiest way to get this library is to install
-     Xcode 4.2 or later.  However if you want to install tip-of-trunk from here
-     (getting the bleeding edge), read on.  However, be warned that Mac OS
-     10.7 will not boot without a valid copy of <code>libc++.1.dylib</code> in
-     <code>/usr/lib</code>.
-  </p>
-
-  <p>To check out the code, use:</p>
-
-  <ul>
-  <li><code>svn co http://llvm.org/svn/llvm-project/libcxx/trunk libcxx</code></li>
-  </ul>
-
-  <p>
-    Note that for an in-tree build, you should check out libcxx to
-    llvm/projects.
-  </p>
-
-  <p>
-    The following instructions are for building libc++ on FreeBSD, Linux, or Mac
-    using <a href="http://libcxxabi.llvm.org/">libc++abi</a> as the C++ ABI
-    library. On Linux, it is also possible to use
-    <a href="#libsupcxx">libsupc++</a> or <a href="#libcxxrt">libcxxrt</a>.
-  </p>
-
-  <p>In-tree build:</p>
-  <ul>
-    <li><code>cd where-you-want-to-live</code></li>
-    <li>Check out libcxx and <a href="http://libcxxabi.llvm.org/">libcxxabi</a>
-      into llvm/projects</li>
-    <li><code>cd where-you-want-to-build</code></li>
-    <li><code>mkdir build &amp;&amp; cd build</code></li>
-    <li><code>cmake path/to/llvm # Linux may require -DCMAKE_C_COMPILER=clang
-        -DCMAKE_CXX_COMPILER=clang++</code></li>
-    <li><code>make cxx</code></li>
-  </ul>
-
-  <p>Out-of-tree buildc:</p>
-  <ul>
-    <li><code>cd where-you-want-to-live</code></li>
-    <li>Check out libcxx and llvm</li>
-    <li>If not on a Mac, also check out
-      <a href="http://libcxxabi.llvm.org/">libcxxabi</a></li>
-    <li><code>cd where-you-want-to-build</code></li>
-    <li><code>mkdir build &amp;&amp; cd build</code></li>
-    <li><code>cmake -DLLVM_PATH=path/to/llvm
-        -DLIBCXX_CXX_ABI=libcxxabi
-        -DLIBCXX_CXX_ABI_INCLUDE_PATHS=path/to/libcxxabi/include
-        -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++
-        path/to/libcxx
-    </code></li>
-    <li><code>make</code></li>
-  </ul>
-
-  <p>To run the tests:</p>
-  <ul>
-  <li><code>make check-libcxx</code></li>
-  </ul>
-
-  <p>If you wish to run a subset of the test suite:</p>
-  <ul>
-    <li><code>cd path/to/libcxx/libcxx</code></li>
-    <li><code>alias lit='python path/to/llvm/utils/lit/lit.py'</code></li>
-    <li><code>export
-        LIBCXX_SITE_CONFIG=path/to/build/dir/projects/libcxx/test/lit.site.cfg
-        </code></li>
-    <li><code>lit -sv test/re/ # or whichever subset of tests you're interested
-        in</code></li>
-  </ul>
-  <p>The above is currently quite inconvenient. Sorry! We're working on it!</p>
-
-  <p>More information on using LIT can be found
-    <a href="http://llvm.org/docs/CommandGuide/lit.html">here</a>. For more
-    general information about the LLVM testing infrastructure, see the
-    <a href="http://llvm.org/docs/TestingGuide.html">LLVM Testing Infrastructure
-      Guide</a>
-  </p>
-
-  <p>
-    Shared libraries for libc++ should now be present in llvm/build/lib. Note
-    that it is safest to use this from its current location rather than
-    replacing your system's libc++ (if it has one, if not, go right ahead).
-  </p>
-
-  <p>
-    Mac users, remember to be careful when replacing the system's libc++.
-    <strong>Your system will not be able to boot without a functioning
-    libc++.</strong>
-  </p>
+    The documentation for building and using libc++ can be found below.
+    <ul>
+      <li><a href="http://libcxx.llvm.org/docs/UsingLibcxx.html">
+        <b>Using libc++</b></a>
+          Documentation on using the library in your programs</li>
+      <li><a href="http://libcxx.llvm.org/docs/BuildingLibcxx.html">
+        <b>Building libc++</b></a>
+          Documentation on building the library using CMake</li>
+      <li><a href="http://libcxx.llvm.org/docs/TestingLibcxx.html">
+        <b>Testing libc++</b></a>
+          Documentation for developers wishing to test the library</li>
+    </ul>
 
   <!--=====================================================================-->
   <h3>Notes and Known Issues</h3>
@@ -279,65 +201,6 @@
     <a href="http://lists.llvm.org/mailman/listinfo/cfe-dev">clang mailing list</a>.</p>
 
   <!--=====================================================================-->
-  <h2>Using libc++ in your programs</h2>
-  <!--=====================================================================-->
-
-  <!--=====================================================================-->
-  <h3>FreeBSD and Mac OS X</h3>
-  <!--=====================================================================-->
-
-  <p>
-    To use your system-installed libc++ with clang you can:
-  </p>
-
-  <ul>
-    <li><code>clang++ -stdlib=libc++ test.cpp</code></li>
-    <li><code>clang++ -std=c++11 -stdlib=libc++ test.cpp</code></li>
-  </ul>
-
-  <p>
-    To use your tip-of-trunk libc++ on Mac OS with clang you can:
-  </p>
-
-  <ul>
-    <li><code>export DYLD_LIBRARY_PATH=path/to/build/lib</code>
-    <li><code>clang++ -std=c++11 -stdlib=libc++ -nostdinc++
-         -I&lt;path-to-libcxx&gt;/include -L&lt;path-to-libcxx&gt;/lib
-         test.cpp</code></li>
-  </ul>
-
-  <!--=====================================================================-->
-  <h3>Linux</h3>
-  <!--=====================================================================-->
-
-  <p>
-    You will need to keep the source tree of
-    <a href="http://libcxxabi.llvm.org">libc++abi</a> available on your build
-    machine and your copy of the libc++abi shared library must be placed where
-    your linker will find it.
-  </p>
-
-  <p>
-    Unfortunately you can't simply run clang with "-stdlib=libc++" at this
-    point, as clang is set up to link for libc++ linked to libsupc++.  To get
-    around this you'll have to set up your linker yourself (or patch clang).
-    For example:
-  </p>
-
-  <ul>
-    <li><code>clang++ -stdlib=libc++ helloworld.cpp -nodefaultlibs -lc++ -lc++abi -lm -lc -lgcc_s -lgcc</code></li>
-  </ul>
-
-  <p>
-    Alternately, you could just add libc++abi to your libraries list, which in
-    most situations will give the same result:
-  </p>
-
-  <ul>
-    <li><code>clang++ -stdlib=libc++ helloworld.cpp -lc++abi</code></li>
-  </ul>
-
-  <!--=====================================================================-->
   <h2>Bug reports and patches</h2>
   <!--=====================================================================-->
 
@@ -355,136 +218,6 @@
   </p>
 
   <!--=====================================================================-->
-  <h2 id="libsupcxx">Build on Linux using CMake and libsupc++.</h2>
-  <!--=====================================================================-->
-
-  <p>
-     You will need libstdc++ in order to provide libsupc++.
-  </p>
-
-  <p>
-     Figure out where the libsupc++ headers are on your system. On Ubuntu this
-     is <code>/usr/include/c++/&lt;version&gt;</code> and
-     <code>/usr/include/c++/&lt;version&gt;/&lt;target-triple&gt;</code>
-  </p>
-
-  <p>
-     You can also figure this out by running
-     <pre>
-$ echo | g++ -Wp,-v -x c++ - -fsyntax-only
-ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu"
-ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/4.7/../../../../x86_64-linux-gnu/include"
-#include "..." search starts here:
-#include &lt;...&gt; search starts here:
- /usr/include/c++/4.7
- /usr/include/c++/4.7/x86_64-linux-gnu
- /usr/include/c++/4.7/backward
- /usr/lib/gcc/x86_64-linux-gnu/4.7/include
- /usr/local/include
- /usr/lib/gcc/x86_64-linux-gnu/4.7/include-fixed
- /usr/include/x86_64-linux-gnu
- /usr/include
-End of search list.
-     </pre>
-
-      Note the first two entries happen to be what we are looking for. This
-      may not be correct on other platforms.
-  </p>
-
-  <p>
-     We can now run CMake:
-     <ul>
-       <li><code>CC=clang CXX=clang++ cmake -G "Unix Makefiles"
-                -DLIBCXX_CXX_ABI=libstdc++
-                -DLIBCXX_CXX_ABI_INCLUDE_PATHS="/usr/include/c++/4.7/;/usr/include/c++/4.7/x86_64-linux-gnu/"
-                -DCMAKE_BUILD_TYPE=Release
-                -DCMAKE_INSTALL_PREFIX=/usr
-                &lt;libc++-source-dir&gt;</code></li>
-       <li>You can also substitute <code>-DLIBCXX_CXX_ABI=libsupc++</code>
-       above, which will cause the library to be linked to libsupc++ instead
-       of libstdc++, but this is only recommended if you know that you will
-       never need to link against libstdc++ in the same executable as libc++.
-       GCC ships libsupc++ separately but only as a static library.  If a
-       program also needs to link against libstdc++, it will provide its
-       own copy of libsupc++ and this can lead to subtle problems.
-       <li><code>make</code></li>
-       <li><code>sudo make install</code></li>
-     </ul>
-     <p>
-        You can now run clang with -stdlib=libc++.
-     </p>
-  </p>
-
-  <!--=====================================================================-->
-  <h2 id="libcxxrt">Build on Linux using CMake and libcxxrt.</h2>
-  <!--=====================================================================-->
-
-  <p>
-     You will need to keep the source tree of
-     <a href="https://github.com/pathscale/libcxxrt/">libcxxrt</a> available
-     on your build machine and your copy of the libcxxrt shared library must
-     be placed where your linker will find it.
-  </p>
-
-  <p>
-     We can now run CMake:
-     <ul>
-       <li><code>CC=clang CXX=clang++ cmake -G "Unix Makefiles"
-                -DLIBCXX_CXX_ABI=libcxxrt
-                -DLIBCXX_CXX_ABI_INCLUDE_PATHS="&lt;libcxxrt-source-dir&gt;/src"
-                -DCMAKE_BUILD_TYPE=Release
-                -DCMAKE_INSTALL_PREFIX=/usr
-                &lt;libc++-source-dir&gt;</code></li>
-       <li><code>make</code></li>
-       <li><code>sudo make install</code></li>
-     </ul>
-     <p>
-        Unfortunately you can't simply run clang with "-stdlib=libc++" at this point, as
-        clang is set up to link for libc++ linked to libsupc++.  To get around this
-        you'll have to set up your linker yourself (or patch clang).  For example,
-        <ul>
-          <li><code>clang++ -stdlib=libc++ helloworld.cpp -nodefaultlibs -lc++ -lcxxrt -lm -lc -lgcc_s -lgcc</code></li>
-        </ul>
-        Alternately, you could just add libcxxrt to your libraries list, which in most
-        situations will give the same result:
-        <ul>
-          <li><code>clang++ -stdlib=libc++ helloworld.cpp -lcxxrt</code></li>
-        </ul>
-     </p>
-  </p>
-
-  <!--=====================================================================-->
-  <h2 id="local-abi">Using a local ABI library</h2>
-  <!--=====================================================================-->
-  <p>
-    <strong>Note: This is not recommended in almost all cases.</strong><br>
-    Generally these instructions should only be used when you can't install
-    your ABI library.
-  </p>
-  <p>
-    Normally you must link libc++ against a ABI shared library that the
-    linker can find.  If you want to build and test libc++ against an ABI
-    library not in the linker's path you need to set
-    <code>-DLIBCXX_CXX_ABI_LIBRARY_PATH=/path/to/abi/lib</code> when
-    configuring CMake.
-  </p>
-  <p>
-    An example build using libc++abi would look like:
-    <ul>
-    <li><code>CC=clang CXX=clang++ cmake
-              -DLIBCXX_CXX_ABI=libc++abi
-              -DLIBCXX_CXX_ABI_INCLUDE_PATHS="/path/to/libcxxabi/include"
-              -DLIBCXX_CXX_ABI_LIBRARY_PATH="/path/to/libcxxabi-build/lib"
-              path/to/libcxx</code></li>
-    <li><code>make</code></li>
-    </ul>
-  </p>
-  <p>
-    When testing libc++ LIT will automatically link against the proper ABI
-    library.
-  </p>
-
-  <!--=====================================================================-->
   <h2>Design Documents</h2>
   <!--=====================================================================-->
 
@@ -493,7 +226,6 @@ End of search list.
 <li><a href="type_traits_design.html"><tt>&lt;type_traits&gt;</tt></a></li>
 <li><a href="http://cplusplusmusings.wordpress.com/2012/07/05/clang-and-standard-libraries-on-mac-os-x/">Excellent notes by Marshall Clow</a></li>
 <li><a href="debug_mode.html">Status of debug mode</a></li>
-<li><a href="lit_usage.html">LIT usage guide</a></li>
 </ul>
 
 </div>
diff --git a/www/kona.html b/www/kona.html
deleted file mode 100644
index 8fdfba163e4a..000000000000
--- a/www/kona.html
+++ /dev/null
@@ -1,154 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
-          "http://www.w3.org/TR/html4/strict.dtd">
-<!-- Material used from: HTML 4.01 specs: http://www.w3.org/TR/html401/ -->
-<html>
-<head>
-  <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-  <title>libc++ Kona Status</title>
-  <link type="text/css" rel="stylesheet" href="menu.css">
-  <link type="text/css" rel="stylesheet" href="content.css">
-</head>
-
-<body>
-<div id="menu">
-  <div>
-    <a href="http://llvm.org/">LLVM Home</a>
-  </div>
-
-  <div class="submenu">
-    <label>libc++ Info</label>
-    <a href="/index.html">About</a>
-  </div>
-
-  <div class="submenu">
-    <label>Quick Links</label>
-    <a href="http://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
-    <a href="http://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
-    <a href="http://llvm.org/bugs/">Bug Reports</a>
-    <a href="http://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="http://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
-  </div>
-</div>
-
-<div id="content">
-  <!--*********************************************************************-->
-  <h1>libc++ Kona Status</h1>
-  <!--*********************************************************************-->
-
-  <p>This is a temporary page; please check the c++1z status <a href="http://libcxx.llvm.org/cxx1z_status.html">here</a></p>
-  <p>This page shows the status of the papers and issues that are expected to be adopted in Kona.</p>
-
-  <p>The groups that have contributed papers:
-  <ul>
-    <li>LWG - Library working group</li>
-    <li>CWG - Core Language Working group</li>
-    <li>SG1 - Study group #1 (Concurrency working group)</li>
-  </ul>
-  </p>
-  
-  <h3>Paper Status</h3>
-  <table id="papers" border="1">
-	<tr><th>Paper #</th><th>Group</th><th>Paper Name</th><th>Meeting</th><th>Status</th><th>First released version</th></tr>
-<!--
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3346.pdf">3346</a></td><td>LWG</td><td>Terminology for Container Element Requirements - Rev 1</td><td>Kona</td><td>Complete</td><td>3.4</td></tr>
--->
-<!--  	<tr><td></td><td></td><td></td><td></td><td></td><td></td></tr> -->
-  </table>
-
-  <h3>Library Working group Issues Status</h3>
-  <table id="issues" border="1">
-	<tr><th>Issue #</th><th>Issue Name</th><th>Meeting</th><th>Status</th></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#1169">1169</a></td><td><tt>num_get</tt> not fully compatible with <tt>strto*</tt></td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2072">2072</a></td><td>Unclear wording about capacity of temporary buffers</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2101">2101</a></td><td>Some transformation types can produce impossible types</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2111">2111</a></td><td>Which <tt>unexpected</tt>&#47;<tt>terminate</tt> handler is called from the exception handling runtime?</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2119">2119</a></td><td>Missing <tt>hash</tt> specializations for extended integer types</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2127">2127</a></td><td>Move-construction with <tt>raw_storage_iterator</tt></td><td>Kona</td><td>Patch Ready</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2133">2133</a></td><td>Attitude to overloaded comma for iterators</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2156">2156</a></td><td>Unordered containers' <tt>reserve(n)</tt> reserves for <tt>n-1</tt> elements</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2218">2218</a></td><td>Unclear how containers use <tt>allocator_traits::construct()</tt></td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2219">2219</a></td><td><tt><i>INVOKE</i></tt>-ing a pointer to member with a <tt>reference_wrapper</tt> as the object expression</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2224">2224</a></td><td>Ambiguous status of access to non-live objects</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2234">2234</a></td><td><tt>assert()</tt> should allow usage in constant expressions</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2244">2244</a></td><td>Issue on <tt>basic_istream::seekg</tt></td><td>Kona</td><td>Patch Ready</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2250">2250</a></td><td>Follow-up On Library Issue 2207</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2259">2259</a></td><td>Issues in 17.6.5.5 rules for member functions</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2273">2273</a></td><td><tt>regex_match</tt> ambiguity</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2336">2336</a></td><td><tt>is_trivially_constructible/is_trivially_assignable</tt> traits are always false</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2353">2353</a></td><td><tt>std::next</tt> is over-constrained</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2367">2367</a></td><td><tt>pair</tt> and <tt>tuple</tt> are not correctly implemented for <tt>is_constructible</tt> with no args</td><td>Kona</td><td>Patch Ready</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2380">2380</a></td><td>May <tt>&lt;cstdlib&gt;</tt> provide <tt>long ::abs(long)</tt> and <tt>long long ::abs(long long)</tt>?</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2384">2384</a></td><td>Allocator's <tt>deallocate</tt> function needs better specification</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2385">2385</a></td><td><tt>function::assign</tt> allocator argument doesn't make sense</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2435">2435</a></td><td><tt>reference_wrapper::operator()</tt>'s Remark should be deleted</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2447">2447</a></td><td>Allocators and <tt>volatile</tt>-qualified value types</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2462">2462</a></td><td><tt>std::ios_base::failure</tt> is overspecified</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2466">2466</a></td><td><tt>allocator_traits::max_size()</tt> default behavior is incorrect</td><td>Kona</td><td>Patch Ready</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2469">2469</a></td><td>Wrong specification of Requires clause of <tt>operator[]</tt> for <tt>map</tt> and <tt>unordered_map</tt></td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2473">2473</a></td><td><tt>basic_filebuf</tt>'s relation to C <tt>FILE</tt> semantics</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2476">2476</a></td><td><tt>scoped_allocator_adaptor</tt> is not assignable</td><td>Kona</td><td>Patch Ready</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2477">2477</a></td><td>Inconsistency of wordings in <tt>std::vector::erase()</tt> and <tt>std::deque::erase()</tt></td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2483">2483</a></td><td><tt>throw_with_nested()</tt> should use <tt>is_final</tt></td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2484">2484</a></td><td><tt>rethrow_if_nested()</tt> is doubly unimplementable</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2485">2485</a></td><td><tt>get()</tt> should be overloaded for <tt>const tuple&amp;&amp;</tt></td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2486">2486</a></td><td><tt>mem_fn()</tt> should be required to use perfect forwarding</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2487">2487</a></td><td><tt>bind()</tt> should be <tt>const</tt>-overloaded, not <i>cv</i>-overloaded</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2489">2489</a></td><td><tt>mem_fn()</tt> should be <tt>noexcept</tt></td><td>Kona</td><td>Patch Ready</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2492">2492</a></td><td>Clarify requirements for <tt>comp</tt></td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2494">2494</a></td><td>[fund.ts.v2] <tt>ostream_joiner</tt> needs <tt>noexcept</tt></td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2495">2495</a></td><td>There is no such thing as an Exception Safety element</td><td>Kona</td><td></td></tr>
-
-<!--
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#1214">1214</a></td><td>Insufficient/inconsistent key immutability requirements for associative containers</td><td>Urbana</td><td></td></tr>
--->
-<!-- 	<tr><td></td><td></td><td></td><td></td></tr> -->
-  </table>
-
-<h3>Comments about the issues</h3>
-<ul>
-<li>1169 - We currently have a single function __num_get_float that calls strtold_l, and then casts down to the appropriate floating point type.  That will have to change.</li>
-<li><i>2072 - We already do this; this is just making the wording better.</i></li>
-<li>2101 - Need to write some careful test cases. In particular, need to check function types with/without const/ref qualifiers.  Currently we get this wrong. Installing metashell to play with these.</li>
-<li><i>2111 - Resolved an ambiguity by calling it out. No code change required.</i></li>
-<li>2119 - Hashes for all integral and enumeration types. Research needed</li>
-<li><i>2127 - Add a new member to raw_storage_iterator. Looks simple.</i> <b>Patch Available</b></li>
-<li><i>2133 - We do this already; thanks Eric.</i></li>
-<li>2156 - check and make sure that we already do this. Write a test.</li>
-<li>2181 - I suspect that this will not require any code changes, but will need to be read carefully.</li>
-<li>2218 - Shouldn't require any code changes.</li>
-<li>2219 - Sizable changes required. INVOKE needs 2 additional overloads and plenty of tests. I'm not going to back port this to C++03. (Eric)</li>
-<li>2224 - </li>
-<li>2234 - </li>
-<li><i>2244 - We don't do this; easy fix. <b>Patch Available</b></i></li>
-<li>2250 - Looks like wording cleanup. Need to check more closely, but I think there's no code changes here.</li>
-<li><i>2259 - No code changes needed here.</i></li>
-<li>2273 - </li>
-<li>2336 - <b>Check later</b></li>
-<li>2353 - Simple change, needs a test. (test probably used to exist)</li>
-<li><i>2367 - <b>Patch Available as D13750</b> (Eric)</i></li>
-<li><i>2380 - No code changes here; we already do this.</i></li>
-<li><i>2384 - Wording cleanup; no code change required</i></li>
-<li>2385 - Removing broken signatures. Only question is "how far back"?</li>
-<li><i>2435 - Wording cleanup; no code change required</i></li>
-<li><i>2447 - This is a relaxation of a requirement that we satisfy. No changes needed.</i>.</li>
-<li><i>2462 - Added a simple test. No code change needed</i> <b>Patch Available</b></li>
-<li><i>2466 - Simple change; need a test.</i> <b>Patch Available</b></li>
-<li>2469 - This is a follow on to 2464, which we're done. This restates a bunch of operations in terms of newer ops. Probably refactoring to do here, but tests shouldn't change.</li>
-<li><i>2473 - There are two changes here; one to <tt>filebuf::seekpos</tt> and the other to <tt>filebuf::sync</tt>. We do both of these already.</i></li>
-<li><i>2476 - Just needed tests.</i> <b>Patch Available</b></li>
-<li><i>2477 - Wording cleanup.</i></li>
-<li><i>2483 - We already do this.</i></li>
-<li><i>2484 - We already do this.</i></li>
-<li>2485 - Ask Eric to do it. </li>
-<li>2486 - Lots of code changes, all mechanical. Tests will be sizable.</li>
-<li><i>2487 - This is removing a requirement on bind(), which we don't currently satisfy. So, nothing to do.</i></li>
-<li><i>2489 - Looks easy. Just add some NOEXCEPT, and tests.</i> <b>Patch Available</b></li>
-<li><i>2492 - Wording cleanup; no code changes needed.</i></li>
-<li>2494 - My implementation of this (not checked in) already has these.</li>
-<li>2494 - </li>
-</ul>
-
-<p>Last Updated: 5-Oct-2015</p>
-</div>
-</body>
-</html>
diff --git a/www/lit_usage.html b/www/lit_usage.html
deleted file mode 100644
index 2fcb2d0a5f97..000000000000
--- a/www/lit_usage.html
+++ /dev/null
@@ -1,207 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
-          "http://www.w3.org/TR/html4/strict.dtd">
-<!-- Material used from: HTML 4.01 specs: http://www.w3.org/TR/html401/ -->
-<html>
-<head>
-  <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-  <title>Testing libc++ using LIT</title>
-  <link type="text/css" rel="stylesheet" href="menu.css">
-  <link type="text/css" rel="stylesheet" href="content.css">
-  <style>
-    .lit-option {
-      padding-top: 0.5em;
-      margin-bottom: 0.0em;
-      font-size: medium;
-      color: #2d58b7
-    }
-    .lit-option-desc {
-      display: block;
-      margin-top: 0em;
-      margin-bottom: 0em;
-      margin-left: 20px;
-      margin-right: 20px;
-    }
-  </style>
-</head>
-
-<body>
-<div id="menu">
-  <div>
-    <a href="http://llvm.org/">LLVM Home</a>
-  </div>
-
-  <div class="submenu">
-    <label>libc++ Info</label>
-    <a href="/index.html">About</a>
-  </div>
-
-  <div class="submenu">
-    <label>Quick Links</label>
-    <a href="http://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
-    <a href="http://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
-    <a href="http://llvm.org/bugs/">Bug Reports</a>
-    <a href="http://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="http://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
-  </div>
-</div>
-
-<div id="content">
-<!--*********************************************************************-->
-                     <h1>Testing libc++ using LIT</h1>
-<!--*********************************************************************-->
-<p>
-libc++ uses LIT to configure and run its tests. The primary way to run the
-libc++ tests is by using <code>make check-libcxx</code>. However since libc++
-can be used in any number of possible configurations it is important to
-customize the way LIT builds and runs the tests. This guide provides
-information on how to use LIT directly to test libc++.
-</p>
-<p>
-Documentation for LIT can be found
-<a href="http://llvm.org/docs/CommandGuide/lit.html">here</a>.
-</p>
-
-<!--*********************************************************************-->
-                        <h2>Getting Started</h2>
-<!--*********************************************************************-->
-<p>
-After building libc++ use the following commands before you start using LIT to
-test.
-</p>
-<ul>
-  <li><code>alias lit='python path/to/llvm/utils/lit/lit.py'</code></li>
-  <li><code>export LIBCXX_SITE_CONFIG=path/to/build-libcxx/test/lit.site.cfg</code></li>
-</ul>
-<p>
-You can now run the libc++ tests by running:
-</p>
-<ul>
-  <li><code>cd path/to/libcxx</code></li>
-  <li><code>lit -sv ./test</code></li>
-</ul>
-<p>
-To only run a subsection of the tests use:
-<ul>
-  <li><code>lit -sv test/std/numerics # Run only the numeric tests</code></li>
-</ul>
-
-<!--*********************************************************************-->
-                     <h2>Customization Options</h2>
-<!--*********************************************************************-->
-<p>
-libc++'s testsuite provides multiple options to configure the way the tests
-are build and run. To use these options you pass them on the LIT command line
-as <code>--param NAME</code> or <code>--param NAME=VALUE</code>. Some options
-have default values specified during CMake's configuration. Passing the option
-on the command line will override the default.
-</p>
-
-
-<p>
-<h3 class="lit-option">libcxx_site_config=&lt;path/to/lit.site.cfg&gt;</h3>
-<blockquote class="lit-option-desc">
-Specify the site configuration to use when running the tests. This option
-overrides the enviroment variable <code>LIBCXX_SITE_CONFIG</code>
-</blockquote>
-</p>
-
-<p>
-<h3 class="lit-option">libcxx_headers=&lt;path/to/headers&gt;</h3>
-<blockquote class="lit-option-desc">
-Specify the libc++ headers that are tested. By default the headers in the source
-tree are used.
-</blockquote>
-</p>
-
-<p>
-<h3 class="lit-option">libcxx_library=&lt;path/to/libc++.so&gt;</h3>
-<blockquote class="lit-option-desc">
-Specify the libc++ library that is tested. By default the library in the build
-directory is used. This option cannot be used when <code>use_system_lib</code>
-is provided.
-</blockquote>
-</p>
-
-<p>
-<h3 class="lit-option">use_system_lib=&lt;bool&gt;</h3>
-<blockquote class="lit-option-desc">
-<b>Default: </b><code>False</code></br>
-Enable or disable testing against the installed version of libc++ library.
-Note: This does not use the installed headers.
-</blockquote>
-</p>
-
-<p>
-<h3 class="lit-option">use_lit_shell=&lt;bool&gt;</h3>
-<blockquote class="lit-option-desc">
-Enable or disable the use of LIT's internal shell in ShTests. If the enviroment
-variable <code>LIT_USE_INTERNAL_SHELL</code> is present then that is used as the
-default value. Otherwise the default value is <code>True</code> on Windows and
-<code>False</code> on every other platform.
-</blockquote>
-</p>
-
-<p>
-<h3 class="lit-option">no_default_flags=&lt;bool&gt;</h3>
-<blockquote class="lit-option-desc">
-<b>Default: </b><code>False</code></br>
-Disable all default compile and link flags from being added. When this option is
-used only flags specified using the <code>compile_flags</code> and
-<code>link_flags</code> will be used.
-</blockquote>
-</p>
-
-<p>
-<h3 class="lit-option">compile_flags="&lt;list-of-args&gt;"</h3>
-<blockquote class="lit-option-desc">
-Specify additional compile flags as a space delimited string.
-Note: This options should not be used to change the standard version used.
-</blockquote>
-</p>
-
-<p>
-<h3 class="lit-option">link_flags="&lt;list-of-args&gt;"</h3>
-<blockquote class="lit-option-desc">
-Specify additional link  flags as a space delimited string.
-</blockquote>
-</p>
-
-<p>
-<h3 class="lit-option">std=&lt;standard version&gt;</h3>
-<blockquote class="lit-option-desc">
-<b>Values: </b><code>c++98, c++03, c++11, c++14, c++1z</code></br>
-Change the standard version used when building the tests.
-</blockquote>
-</p>
-
-<p>
-<h3 class="lit-option">debug_level=&lt;level&gt;</h3>
-<blockquote class="lit-option-desc">
-<b>Values: </b><code>0, 1</code></br>
-Enable the use of debug mode. Level 0 enables assertions and level 1 enables
-assertions and debugging of iterator misuse.
-</blockquote>
-</p>
-
-<p>
-<h3 class="lit-option">use_sanitizer=&lt;sanitizer name&gt;</h3>
-<blockquote class="lit-option-desc">
-<b>Values: </b><code>Memory, MemoryWithOrigins, Address, Undefined</code></br>
-Run the tests using the given sanitizer. If <code>LLVM_USE_SANITIZER</code>
-was given when building libc++ then that sanitizer will be used by default.
-</blockquote>
-</p>
-
-<p>
-<h3 class="lit-option">color_diagnostics</h3>
-<blockquote class="lit-option-desc">
-Enable the use of colorized compile diagnostics. If the
-<code>color_diagnostics</code> option is specified or the enviroment variable
-<code>LIBCXX_COLOR_DIAGNOSTICS</code> is present then color diagnostics will be
-enabled.
-</blockquote>
-</p>
-
-</div>
-</body>
-</html>
diff --git a/www/ts1z_status.html b/www/ts1z_status.html
index 9d4a000b0b99..4c460c5d1497 100644
--- a/www/ts1z_status.html
+++ b/www/ts1z_status.html
@@ -72,6 +72,14 @@
 	<tr><td>Time Utilities</td><td>Complete</td></tr>
 	<tr><td>System Error Support</td><td>Complete</td></tr>
   <tr><td></td><td></td></tr>
+      <tr><td>Class memory_resource</td><td>Complete</td></tr>
+      <tr><td>Class template polymorphic_allocator</td><td>Complete</td></tr>
+      <tr><td>Template alias resource_adaptor</td><td>Complete</td></tr>
+      <tr><td>Global memory resources</td><td>Complete</td></tr>
+      <tr><td>Pool resource classes</td><td>Implementation in progress</td></tr>
+      <tr><td>Class monotonic_buffer_resource</td><td>Implementation in progress</td></tr>
+      <tr><td>Alias templates using polymorphic memory resource</td><td>Complete</td></tr>
+  <tr><td></td><td></td></tr>
 	<tr><td>Searchers</td><td>Complete</td></tr>
 	<tr><td>Optional Objects</td><td>Initial implementation complete</td></tr>
 	<tr><td>class any</td><td>Complete</td></tr>
@@ -90,12 +98,12 @@
   
   <h3>Features in Filesystem</h3>
   <table id="Features" border="1">
-	<tr><th>Feature Name</th><th>Status</th></tr>
-	<tr><td>All features</td><td>Not started</td></tr>
+	<tr><th>Feature Name</th><th>Status</th><th>First released version</th></tr>
+	<tr><td>All features</td><td>Complete</td><td>3.9</td></tr>
 
   </table>
 
-  <p>Last Updated: 7-Dec-2015</p>
+  <p>Last Updated: 17-June-2016</p>
 </div>
 </body>
 </html>
diff --git a/www/upcoming_meeting.html b/www/upcoming_meeting.html
new file mode 100644
index 000000000000..1316618e9b41
--- /dev/null
+++ b/www/upcoming_meeting.html
@@ -0,0 +1,137 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
+          "http://www.w3.org/TR/html4/strict.dtd">
+<!-- Material used from: HTML 4.01 specs: http://www.w3.org/TR/html401/ -->
+<html>
+<head>
+  <meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
+  <title>libc++ Upcoming Meeting Status</title>
+  <link type="text/css" rel="stylesheet" href="menu.css">
+  <link type="text/css" rel="stylesheet" href="content.css">
+</head>
+
+<body>
+<div id="menu">
+  <div>
+    <a href="http://llvm.org/">LLVM Home</a>
+  </div>
+
+  <div class="submenu">
+    <label>libc++ Info</label>
+    <a href="/index.html">About</a>
+  </div>
+
+  <div class="submenu">
+    <label>Quick Links</label>
+    <a href="http://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
+    <a href="http://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
+    <a href="http://llvm.org/bugs/">Bug Reports</a>
+    <a href="http://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
+    <a href="http://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+  </div>
+</div>
+
+<div id="content">
+  <!--*********************************************************************-->
+  <h1>libc++ Oulu Status</h1>
+  <!--*********************************************************************-->
+
+  <p>This is a temporary page; please check the c++1z status <a href="http://libcxx.llvm.org/cxx1z_status.html">here</a></p>
+  <p>This page shows the status of the papers and issues that are expected to be adopted in Oulu.</p>
+
+  <p>The groups that have contributed papers:
+  <ul>
+    <li>LWG - Library working group</li>
+    <li>CWG - Core Language Working group</li>
+    <li>SG1 - Study group #1 (Concurrency working group)</li>
+  </ul>
+  </p>
+  
+  <h3>Paper Status</h3>
+  <table id="papers" border="1">
+	<tr><th>Paper #</th><th>Group</th><th>Paper Name</th><th>Meeting</th><th>Status</th><th>First released version</th></tr>
+<!--
+	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3346.pdf">3346</a></td><td>LWG</td><td>Terminology for Container Element Requirements - Rev 1</td><td>Kona</td><td>Complete</td><td>3.4</td></tr>
+-->
+<!--  	<tr><td></td><td></td><td></td><td></td><td></td><td></td></tr> -->
+  </table>
+
+  <h3>Library Working group Issues Status</h3>
+  <table id="issues" border="1">
+	<tr><th>Issue #</th><th>Issue Name</th><th>Meeting</th><th>Status</th></tr>
+
+	<tr><td><a href="http://wg21.link/LWG2181">2181</a></td><td>Exceptions from seed sequence operations</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2309">2309</a></td><td>mutex::lock() should not throw device_or_resource_busy</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2310">2310</a></td><td>Public exposition only member in std::array</td><td>Oulu</td><td>Patch Ready</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2328">2328</a></td><td>Rvalue stream extraction should use perfect forwarding</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2393">2393</a></td><td>std::function's Callable definition is broken</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2426">2426</a></td><td>Issue about compare_exchange</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2436">2436</a></td><td>Comparators for associative containers should always be CopyConstructible</td><td>Oulu</td><td>Patch Ready</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2441">2441</a></td><td>Exact-width atomic typedefs should be provided</td><td>Oulu</td><td>Patch Ready</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2451">2451</a></td><td>[fund.ts.v2] optional<T> should 'forward' T's implicit conversions</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2509">2509</a></td><td>[fund.ts.v2] any_cast doesn't work with rvalue reference targets and cannot move with a value target</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2516">2516</a></td><td>[fund.ts.v2] Public "exposition only" members in observer_ptr</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2542">2542</a></td><td>Missing const requirements for associative containers</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2549">2549</a></td><td>Tuple EXPLICIT constructor templates that take tuple parameters end up taking references to temporaries and will create dangling references</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2550">2550</a></td><td>Wording of unordered container's clear() method complexity</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2551">2551</a></td><td>[fund.ts.v2] "Exception safety" cleanup in library fundamentals required</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2555">2555</a></td><td>[fund.ts.v2] No handling for over-aligned types in optional</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2573">2573</a></td><td>[fund.ts.v2] std::hash<std::experimental::shared_ptr<T>> does not work for arrays</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2596">2596</a></td><td>vector::data() should use addressof</td><td>Oulu</td><td>Patch Ready</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2667">2667</a></td><td>path::root_directory() description is confusing</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2669">2669</a></td><td>recursive_directory_iterator effects refers to non-existent functions</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2670">2670</a></td><td>system_complete refers to undefined variable 'base'</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2671">2671</a></td><td>Errors in Copy</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2673">2673</a></td><td>status() effects cannot be implemented as specified</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2674">2674</a></td><td>Bidirectional iterator requirement on path::iterator is very expensive</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2683">2683</a></td><td>filesystem::copy() says "no effects"</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2684">2684</a></td><td>priority_queue lacking comparator typedef</td><td>Oulu</td><td>Patch Ready</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2685">2685</a></td><td>shared_ptr deleters must not not throw on move construction</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2688">2688</a></td><td>clamp misses preconditions and has extraneous condition on result</td><td>Oulu</td><td>Patch Ready</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2689">2689</a></td><td>Parallel versions of std::copy and std::move shouldn't be in order</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2698">2698</a></td><td>Effect of assign() on iterators/pointers/references</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="http://wg21.link/LWG2706">2706</a></td><td>Error reporting for recursive_directory_iterator::pop() is under-specified</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2707">2707</a></td><td>path construction and assignment should have "string_type&&" overloads</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2710">2710</a></td><td>"Effects: Equivalent to ..." doesn't count "Synchronization:" as determined semantics</td><td>Oulu</td><td>Complete</td></tr>
+  </table>
+
+<h3>Comments about the issues</h3>
+<ul>
+<li>2181 - </li>
+<li>2309 - I don't think there's anything to do here.</li>
+<li>2310 - I think we need a test that checks array::data() == addressof(front()). Other than that, we're good.</li>
+<li>2328 - &lt;istream&gt;:1467 - fix is straightforward.  Need to think about tests.</li>
+<li>2393 - </li>
+<li>2426 - I believe this is just a wording clarification, but need to study it some more.</li>
+<li>2436 - Adds Requirements on compare/hasher. We can static_assert this, and test it.</li>
+<li>2441 - Looks straightforward.</li>
+<li>2451 - <i>Significant work.</i></li>
+<li>2509 - <i>Significant work.</i></li>
+<li>2516 - We don't have an observer_ptr implementation yet.</li>
+<li>2542 - This is probably mostly writing additional tests.</li>
+<li>2549 - Tuple EXPLICIT - Eric?</li>
+<li>2550 - Wording clarification; no code change needed.</li>
+<li>2551 - Wording cleanup; no code change needed.</li>
+<li>2555 - Wording clarification; no code change needed.</li>
+<li>2573 - </li>
+<li>2596 - Turns out we do this already. Needs tests, though.</li>
+<li>2667 - Wording clarification; no code change needed.</li>
+<li>2669 - Wording clarification; no code change needed.</li>
+<li>2670 - Wording clarification; no code change needed.</li>
+<li>2671 - Wording clarification; no code change needed.</li>
+<li>2673 - Wording clarification; no code change needed.</li>
+<li>2674 - We already depend on the requirements being relaxed.</li>
+<li>2683 - We already do this.</li>
+<li>2684 - We already have one; just need to add a test for it.</li>
+<li>2685 - Wording clarification; no code change needed. We don't handle throwing move ctors here anyway.</li>
+<li>2688 - I believe that we already do this. Add more tests</li>
+<li>2689 - We don't have a parallel implementation yet (though I'm working on it).</li>
+<li>2698 - Wording clarification; no code change needed.</li>
+<li>2706 - We already implement the new pop(error_code&) overloads</li>
+<li>2707 - We already implement the new overloads.</li>
+<li>2710 - Wording cleanup; no code change needed.</li>
+</ul>
+
+<p>Last Updated: 7-Jun-2016</p>
+</div>
+</body>
+</html>