Merge 24c7353aa for LLVM update to 316199
Change-Id: I45444731d201b7ab97293d9ccd232fb9b36a68d7
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 33d888b..f0c4d1e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -23,7 +23,7 @@
project(libcxx CXX C)
set(PACKAGE_NAME libcxx)
- set(PACKAGE_VERSION 5.0.0svn)
+ set(PACKAGE_VERSION 6.0.0svn)
set(PACKAGE_STRING "${PACKAGE_NAME} ${PACKAGE_VERSION}")
set(PACKAGE_BUGREPORT "llvm-bugs@lists.llvm.org")
@@ -99,6 +99,9 @@
"LIBCXX_ENABLE_EXPERIMENTAL_LIBRARY;LIBCXX_INSTALL_LIBRARY" OFF)
set(LIBCXX_ABI_VERSION 1 CACHE STRING "ABI version of libc++.")
option(LIBCXX_ABI_UNSTABLE "Unstable ABI of libc++." OFF)
+option(LIBCXX_ABI_FORCE_ITANIUM "Ignore auto-detection and force use of the Itanium ABI.")
+option(LIBCXX_ABI_FORCE_MICROSOFT "Ignore auto-detection and force use of the Microsoft ABI.")
+set(LIBCXX_ABI_DEFINES "" CACHE STRING "A semicolon separated list of ABI macros to define in the site config header.")
option(LIBCXX_USE_COMPILER_RT "Use compiler-rt instead of libgcc" OFF)
if (NOT LIBCXX_ENABLE_SHARED AND NOT LIBCXX_ENABLE_STATIC)
@@ -118,6 +121,7 @@
cxxabi.h
PATHS ${LLVM_MAIN_SRC_DIR}/projects/libcxxabi/include
${LLVM_MAIN_SRC_DIR}/runtimes/libcxxabi/include
+ ${LLVM_MAIN_SRC_DIR}/../libcxxabi/include
NO_DEFAULT_PATH
)
if (LIBCXX_TARGETING_MSVC)
@@ -336,6 +340,10 @@
"when building for Musl with LIBCXX_HAS_MUSL_LIBC.")
endif()
+if (LIBCXX_ABI_FORCE_ITANIUM AND LIBCXX_ABI_FORCE_MICROSOFT)
+ message(FATAL_ERROR "Only one of LIBCXX_ABI_FORCE_ITANIUM and LIBCXX_ABI_FORCE_MICROSOFT can be specified.")
+endif ()
+
#===============================================================================
# Configure System
#===============================================================================
@@ -351,6 +359,13 @@
endif()
file(MAKE_DIRECTORY "${LIBCXX_BINARY_INCLUDE_DIR}")
+set(LIBCXX_INSTALL_PREFIX "" CACHE STRING
+ "Define libc++ destination prefix.")
+
+if (NOT LIBCXX_INSTALL_PREFIX MATCHES "^$|.*/")
+ message(FATAL_ERROR "LIBCXX_INSTALL_PREFIX has to end with \"/\".")
+endif()
+
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${LIBCXX_LIBRARY_DIR})
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${LIBCXX_LIBRARY_DIR})
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${LIBCXX_LIBRARY_DIR})
@@ -586,6 +601,8 @@
config_define(${LIBCXX_ABI_VERSION} _LIBCPP_ABI_VERSION)
endif()
config_define_if(LIBCXX_ABI_UNSTABLE _LIBCPP_ABI_UNSTABLE)
+config_define_if(LIBCXX_ABI_FORCE_ITANIUM _LIBCPP_ABI_FORCE_ITANIUM)
+config_define_if(LIBCXX_ABI_FORCE_MICROSOFT _LIBCPP_ABI_FORCE_MICROSOFT)
config_define_if_not(LIBCXX_ENABLE_GLOBAL_FILESYSTEM_NAMESPACE _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE)
config_define_if_not(LIBCXX_ENABLE_STDIN _LIBCPP_HAS_NO_STDIN)
@@ -598,6 +615,19 @@
config_define_if(LIBCXX_HAS_EXTERNAL_THREAD_API _LIBCPP_HAS_THREAD_API_EXTERNAL)
config_define_if(LIBCXX_BUILD_EXTERNAL_THREAD_LIBRARY _LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL)
config_define_if(LIBCXX_HAS_MUSL_LIBC _LIBCPP_HAS_MUSL_LIBC)
+config_define_if(LIBCXX_NO_VCRUNTIME _LIBCPP_NO_VCRUNTIME)
+
+if (LIBCXX_ABI_DEFINES)
+ set(abi_defines)
+ foreach (abi_define ${LIBCXX_ABI_DEFINES})
+ if (NOT abi_define MATCHES "^_LIBCPP_ABI_")
+ message(SEND_ERROR "Invalid ABI macro ${abi_define} in LIBCXX_ABI_DEFINES")
+ endif()
+ list(APPEND abi_defines "#define ${abi_define}")
+ endforeach()
+ string(REPLACE ";" "\n" abi_defines "${abi_defines}")
+ config_define(${abi_defines} _LIBCPP_ABI_DEFINES)
+endif()
# By default libc++ on Windows expects to use a shared library, which requires
# the headers to use DLL import/export semantics. However when building a
@@ -607,9 +637,10 @@
config_define(ON _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
endif()
+set(site_config_path "${LIBCXX_BINARY_DIR}/__config_site")
if (LIBCXX_NEEDS_SITE_CONFIG)
configure_file("include/__config_site.in"
- "${LIBCXX_BINARY_DIR}/__config_site"
+ "${site_config_path}"
@ONLY)
# Provide the config definitions by included the generated __config_site
@@ -619,6 +650,11 @@
else()
add_compile_flags("-include ${LIBCXX_BINARY_DIR}/__config_site")
endif()
+else()
+ if (EXISTS "${site_config_path}")
+ message(STATUS "Removing stale site configuration ${site_config_path}")
+ file(REMOVE "${site_config_path}")
+ endif()
endif()
#===============================================================================
@@ -639,6 +675,7 @@
#
# However, since some submission systems strip test/ subdirectories, check for
# it before adding it.
+
if(IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/test")
add_subdirectory(test)
endif()
@@ -646,6 +683,15 @@
add_subdirectory(lib/abi)
endif()
+if (LIBCXX_STANDALONE_BUILD AND EXISTS "${LLVM_MAIN_SRC_DIR}/utils/llvm-lit")
+ # Make sure the llvm-lit script is generated into the bin directory, and do
+ # it after adding all tests, since the generated script will only work
+ # correctly discovered tests against test locations from the source tree that
+ # have already been discovered.
+ add_subdirectory(${LLVM_MAIN_SRC_DIR}/utils/llvm-lit
+ ${CMAKE_CURRENT_BINARY_DIR}/llvm-lit)
+endif()
+
if (LIBCXX_INCLUDE_DOCS)
add_subdirectory(docs)
endif()
diff --git a/cmake/Modules/HandleLibCXXABI.cmake b/cmake/Modules/HandleLibCXXABI.cmake
index b404e36..b1f6bee 100644
--- a/cmake/Modules/HandleLibCXXABI.cmake
+++ b/cmake/Modules/HandleLibCXXABI.cmake
@@ -55,7 +55,7 @@
)
if (LIBCXX_INSTALL_HEADERS)
install(FILES "${LIBCXX_BINARY_INCLUDE_DIR}/${fpath}"
- DESTINATION include/c++/v1/${dstdir}
+ DESTINATION ${LIBCXX_INSTALL_PREFIX}include/c++/v1/${dstdir}
COMPONENT libcxx
PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
)
diff --git a/cmake/Modules/HandleOutOfTreeLLVM.cmake b/cmake/Modules/HandleOutOfTreeLLVM.cmake
index 879882d..83948b1 100644
--- a/cmake/Modules/HandleOutOfTreeLLVM.cmake
+++ b/cmake/Modules/HandleOutOfTreeLLVM.cmake
@@ -106,14 +106,22 @@
set(LLVM_ENABLE_SPHINX OFF)
endif()
- # Required LIT Configuration ------------------------------------------------
- # Define the default arguments to use with 'lit', and an option for the user
- # to override.
- set(LIT_ARGS_DEFAULT "-sv --show-xfail --show-unsupported")
- if (MSVC OR XCODE)
- set(LIT_ARGS_DEFAULT "${LIT_ARGS_DEFAULT} --no-progress-bar")
+ # In a standalone build, we don't have llvm to automatically generate the
+ # llvm-lit script for us. So we need to provide an explicit directory that
+ # the configurator should write the script into.
+ set(LLVM_LIT_OUTPUT_DIR "${libcxx_BINARY_DIR}/bin")
+
+ if (LLVM_INCLUDE_TESTS)
+ # Required LIT Configuration ------------------------------------------------
+ # Define the default arguments to use with 'lit', and an option for the user
+ # to override.
+ set(LLVM_EXTERNAL_LIT "${LLVM_MAIN_SRC_DIR}/utils/lit/lit.py")
+ set(LIT_ARGS_DEFAULT "-sv --show-xfail --show-unsupported")
+ if (MSVC OR XCODE)
+ set(LIT_ARGS_DEFAULT "${LIT_ARGS_DEFAULT} --no-progress-bar")
+ endif()
+ set(LLVM_LIT_ARGS "${LIT_ARGS_DEFAULT}" CACHE STRING "Default options for lit")
endif()
- set(LLVM_LIT_ARGS "${LIT_ARGS_DEFAULT}" CACHE STRING "Default options for lit")
# Required doc configuration
if (LLVM_ENABLE_SPHINX)
diff --git a/docs/BuildingLibcxx.rst b/docs/BuildingLibcxx.rst
index c7b5e96..d983bbd 100644
--- a/docs/BuildingLibcxx.rst
+++ b/docs/BuildingLibcxx.rst
@@ -216,6 +216,11 @@
Extra suffix to append to the directory where libraries are to be installed.
This option overrides `LLVM_LIBDIR_SUFFIX`.
+.. option:: LIBCXX_INSTALL_PREFIX:STRING
+
+ **Default**: ``""``
+
+ Define libc++ destination prefix.
.. _libc++experimental options:
@@ -342,6 +347,13 @@
Build the "unstable" ABI version of libc++. Includes all ABI changing features
on top of the current stable version.
+.. option:: LIBCXX_ABI_DEFINES:STRING
+
+ **Default**: ``""``
+
+ A semicolon-separated list of ABI macros to persist in the site config header.
+ See ``include/__config`` for the list of ABI macros.
+
.. _LLVM-specific variables:
LLVM-specific options
diff --git a/docs/DesignDocs/VisibilityMacros.rst b/docs/DesignDocs/VisibilityMacros.rst
index 694882d..993ce2c 100644
--- a/docs/DesignDocs/VisibilityMacros.rst
+++ b/docs/DesignDocs/VisibilityMacros.rst
@@ -90,20 +90,21 @@
The macro has an empty definition with GCC.
**Windows Behavior**: `extern template` and `dllexport` are fundamentally
- incompatible *on a template class* on Windows; the former suppresses
+ incompatible *on a class template* on Windows; the former suppresses
instantiation, while the latter forces it. Specifying both on the same
- declaration makes the template class be instantiated, which is not desirable
+ declaration makes the class template be instantiated, which is not desirable
inside headers. This macro therefore expands to `dllimport` outside of libc++
but nothing inside of it (rather than expanding to `dllexport`); instead, the
explicit instantiations themselves are marked as exported. Note that this
- applies *only* to extern template *classes*. Extern template *functions* obey
+ applies *only* to extern *class* templates. Extern *function* templates obey
regular import/export semantics, and applying `dllexport` directly to the
- extern template declaration is the correct thing to do for them.
+ extern template declaration (i.e. using `_LIBCPP_FUNC_VIS`) is the correct
+ thing to do for them.
**_LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS**
Mark the member functions, typeinfo, and vtable of an explicit instantiation
of a class template as being exported by the libc++ library. This attribute
- must be specified on all template class explicit instantiations.
+ must be specified on all class template explicit instantiations.
It is only necessary to mark the explicit instantiation itself (as opposed to
the extern template declaration) as exported on Windows, as discussed above.
diff --git a/docs/UsingLibcxx.rst b/docs/UsingLibcxx.rst
index 1836646..f54234d 100644
--- a/docs/UsingLibcxx.rst
+++ b/docs/UsingLibcxx.rst
@@ -185,6 +185,26 @@
* Giving `set`, `map`, `multiset`, `multimap` a comparator which is not
const callable.
+**_LIBCPP_NO_VCRUNTIME**:
+ Microsoft's C and C++ headers are fairly entangled, and some of their C++
+ headers are fairly hard to avoid. In particular, `vcruntime_new.h` gets pulled
+ in from a lot of other headers and provides definitions which clash with
+ libc++ headers, such as `nothrow_t` (note that `nothrow_t` is a struct, so
+ there's no way for libc++ to provide a compatible definition, since you can't
+ have multiple definitions).
+
+ By default, libc++ solves this problem by deferring to Microsoft's vcruntime
+ headers where needed. However, it may be undesirable to depend on vcruntime
+ headers, since they may not always be available in cross-compilation setups,
+ or they may clash with other headers. The `_LIBCPP_NO_VCRUNTIME` macro
+ prevents libc++ from depending on vcruntime headers. Consequently, it also
+ prevents libc++ headers from being interoperable with vcruntime headers (from
+ the aforementioned clashes), so users of this macro are promising to not
+ attempt to combine libc++ headers with the problematic vcruntime headers. This
+ macro also currently prevents certain `operator new`/`operator delete`
+ replacement scenarios from working, e.g. replacing `operator new` and
+ expecting a non-replaced `operator new[]` to call the replaced `operator new`.
+
C++17 Specific Configuration Macros
-----------------------------------
**_LIBCPP_ENABLE_CXX17_REMOVED_FEATURES**:
diff --git a/docs/conf.py b/docs/conf.py
index 17fb401..bb231ac 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -47,9 +47,9 @@
# built documents.
#
# The short X.Y version.
-version = '5.0'
+version = '6.0'
# The full version, including alpha/beta/rc tags.
-release = '5.0'
+release = '6.0'
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
diff --git a/fuzzing/fuzzing.cpp b/fuzzing/fuzzing.cpp
new file mode 100644
index 0000000..c441019
--- /dev/null
+++ b/fuzzing/fuzzing.cpp
@@ -0,0 +1,276 @@
+// -*- C++ -*-
+//===------------------------- fuzzing.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.
+//
+//===----------------------------------------------------------------------===//
+
+// A set of routines to use when fuzzing the algorithms in libc++
+// Each one tests a single algorithm.
+//
+// They all have the form of:
+// int `algorithm`(const uint8_t *data, size_t size);
+//
+// They perform the operation, and then check to see if the results are correct.
+// If so, they return zero, and non-zero otherwise.
+//
+// For example, sort calls std::sort, then checks two things:
+// (1) The resulting vector is sorted
+// (2) The resulting vector contains the same elements as the original data.
+
+
+
+#include "fuzzing.h"
+#include <vector>
+#include <algorithm>
+#include <regex>
+
+// If we had C++14, we could use the four iterator version of is_permutation
+
+namespace fuzzing {
+
+// This is a struct we can use to test the stable_XXX algorithms.
+// perform the operation on the key, then check the order of the payload.
+
+struct stable_test {
+ uint8_t key;
+ size_t payload;
+
+ stable_test(uint8_t k) : key(k), payload(0) {}
+ stable_test(uint8_t k, size_t p) : key(k), payload(p) {}
+ };
+
+void swap(stable_test &lhs, stable_test &rhs)
+{
+ using std::swap;
+ swap(lhs.key, rhs.key);
+ swap(lhs.payload, rhs.payload);
+}
+
+struct key_less
+{
+ bool operator () (const stable_test &lhs, const stable_test &rhs) const
+ {
+ return lhs.key < rhs.key;
+ }
+};
+
+struct payload_less
+{
+ bool operator () (const stable_test &lhs, const stable_test &rhs) const
+ {
+ return lhs.payload < rhs.payload;
+ }
+};
+
+struct total_less
+{
+ bool operator () (const stable_test &lhs, const stable_test &rhs) const
+ {
+ return lhs.key == rhs.key ? lhs.payload < rhs.payload : lhs.key < rhs.key;
+ }
+};
+
+bool operator==(const stable_test &lhs, const stable_test &rhs)
+{
+ return lhs.key == rhs.key && lhs.payload == rhs.payload;
+}
+
+
+template<typename T>
+struct is_even
+{
+ bool operator () (const T &t) const
+ {
+ return t % 2 == 0;
+ }
+};
+
+
+template<>
+struct is_even<stable_test>
+{
+ bool operator () (const stable_test &t) const
+ {
+ return t.key % 2 == 0;
+ }
+};
+
+// == sort ==
+
+int sort(const uint8_t *data, size_t size)
+{
+ std::vector<uint8_t> working(data, data + size);
+ std::sort(working.begin(), working.end());
+
+ if (!std::is_sorted(working.begin(), working.end())) return 1;
+ if (!std::is_permutation(data, data + size, working.begin())) return 99;
+ return 0;
+}
+
+
+// == stable_sort ==
+
+int stable_sort(const uint8_t *data, size_t size)
+{
+ std::vector<stable_test> input;
+ for (size_t i = 0; i < size; ++i)
+ input.push_back(stable_test(data[i], i));
+ std::vector<stable_test> working = input;
+ std::stable_sort(working.begin(), working.end(), key_less());
+
+ if (!std::is_sorted(working.begin(), working.end(), key_less())) return 1;
+ auto iter = working.begin();
+ while (iter != working.end())
+ {
+ auto range = std::equal_range(iter, working.end(), *iter, key_less());
+ if (!std::is_sorted(range.first, range.second, total_less())) return 2;
+ iter = range.second;
+ }
+ if (!std::is_permutation(input.begin(), input.end(), working.begin())) return 99;
+ return 0;
+}
+
+// == partition ==
+
+int partition(const uint8_t *data, size_t size)
+{
+ std::vector<uint8_t> working(data, data + size);
+ auto iter = std::partition(working.begin(), working.end(), is_even<uint8_t>());
+
+ if (!std::all_of (working.begin(), iter, is_even<uint8_t>())) return 1;
+ if (!std::none_of(iter, working.end(), is_even<uint8_t>())) return 2;
+ if (!std::is_permutation(data, data + size, working.begin())) return 99;
+ return 0;
+}
+
+
+// == stable_partition ==
+
+int stable_partition (const uint8_t *data, size_t size)
+{
+ std::vector<stable_test> input;
+ for (size_t i = 0; i < size; ++i)
+ input.push_back(stable_test(data[i], i));
+ std::vector<stable_test> working = input;
+ auto iter = std::stable_partition(working.begin(), working.end(), is_even<stable_test>());
+
+ if (!std::all_of (working.begin(), iter, is_even<stable_test>())) return 1;
+ if (!std::none_of(iter, working.end(), is_even<stable_test>())) return 2;
+ if (!std::is_sorted(working.begin(), iter, payload_less())) return 3;
+ if (!std::is_sorted(iter, working.end(), payload_less())) return 4;
+ if (!std::is_permutation(input.begin(), input.end(), working.begin())) return 99;
+ return 0;
+}
+
+// == nth_element ==
+// use the first element as a position into the data
+int nth_element (const uint8_t *data, size_t size)
+{
+ if (size <= 1) return 0;
+ const size_t partition_point = data[0] % size;
+ std::vector<uint8_t> working(data + 1, data + size);
+ const auto partition_iter = working.begin() + partition_point;
+ std::nth_element(working.begin(), partition_iter, working.end());
+
+// nth may be the end iterator, in this case nth_element has no effect.
+ if (partition_iter == working.end())
+ {
+ if (!std::equal(data + 1, data + size, working.begin())) return 98;
+ }
+ else
+ {
+ const uint8_t nth = *partition_iter;
+ if (!std::all_of(working.begin(), partition_iter, [=](uint8_t v) { return v <= nth; }))
+ return 1;
+ if (!std::all_of(partition_iter, working.end(), [=](uint8_t v) { return v >= nth; }))
+ return 2;
+ if (!std::is_permutation(data + 1, data + size, working.begin())) return 99;
+ }
+
+ return 0;
+}
+
+// == partial_sort ==
+// use the first element as a position into the data
+int partial_sort (const uint8_t *data, size_t size)
+{
+ if (size <= 1) return 0;
+ const size_t sort_point = data[0] % size;
+ std::vector<uint8_t> working(data + 1, data + size);
+ const auto sort_iter = working.begin() + sort_point;
+ std::partial_sort(working.begin(), sort_iter, working.end());
+
+ if (sort_iter != working.end())
+ {
+ const uint8_t nth = *std::min_element(sort_iter, working.end());
+ if (!std::all_of(working.begin(), sort_iter, [=](uint8_t v) { return v <= nth; }))
+ return 1;
+ if (!std::all_of(sort_iter, working.end(), [=](uint8_t v) { return v >= nth; }))
+ return 2;
+ }
+ if (!std::is_sorted(working.begin(), sort_iter)) return 3;
+ if (!std::is_permutation(data + 1, data + size, working.begin())) return 99;
+
+ return 0;
+}
+
+
+// -- regex fuzzers
+
+static int regex_helper(const uint8_t *data, size_t size, std::regex::flag_type flag)
+{
+ if (size > 0)
+ {
+ try
+ {
+ std::string s((const char *)data, size);
+ std::regex re(s, flag);
+ return std::regex_match(s, re) ? 1 : 0;
+ }
+ catch (std::regex_error &ex) {}
+ }
+ return 0;
+}
+
+
+int regex_ECMAScript (const uint8_t *data, size_t size)
+{
+ (void) regex_helper(data, size, std::regex_constants::ECMAScript);
+ return 0;
+}
+
+int regex_POSIX (const uint8_t *data, size_t size)
+{
+ (void) regex_helper(data, size, std::regex_constants::basic);
+ return 0;
+}
+
+int regex_extended (const uint8_t *data, size_t size)
+{
+ (void) regex_helper(data, size, std::regex_constants::extended);
+ return 0;
+}
+
+int regex_awk (const uint8_t *data, size_t size)
+{
+ (void) regex_helper(data, size, std::regex_constants::awk);
+ return 0;
+}
+
+int regex_grep (const uint8_t *data, size_t size)
+{
+ (void) regex_helper(data, size, std::regex_constants::grep);
+ return 0;
+}
+
+int regex_egrep (const uint8_t *data, size_t size)
+{
+ (void) regex_helper(data, size, std::regex_constants::egrep);
+ return 0;
+}
+
+} // namespace fuzzing
diff --git a/fuzzing/fuzzing.h b/fuzzing/fuzzing.h
new file mode 100644
index 0000000..6624955
--- /dev/null
+++ b/fuzzing/fuzzing.h
@@ -0,0 +1,41 @@
+// -*- C++ -*-
+//===-------------------------- fuzzing.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_FUZZING
+#define _LIBCPP_FUZZING
+
+#include <cstddef> // for size_t
+#include <cstdint> // for uint8_t
+
+namespace fuzzing {
+
+// These all return 0 on success; != 0 on failure
+ int sort (const uint8_t *data, size_t size);
+ int stable_sort (const uint8_t *data, size_t size);
+ int partition (const uint8_t *data, size_t size);
+ int stable_partition (const uint8_t *data, size_t size);
+
+// partition and stable_partition take Bi-Di iterators.
+// Should test those, too
+
+ int nth_element (const uint8_t *data, size_t size);
+ int partial_sort (const uint8_t *data, size_t size);
+
+// Various flavors of regex
+ int regex_ECMAScript (const uint8_t *data, size_t size);
+ int regex_POSIX (const uint8_t *data, size_t size);
+ int regex_extended (const uint8_t *data, size_t size);
+ int regex_awk (const uint8_t *data, size_t size);
+ int regex_grep (const uint8_t *data, size_t size);
+ int regex_egrep (const uint8_t *data, size_t size);
+
+} // namespace fuzzing
+
+#endif // _LIBCPP_FUZZING
diff --git a/include/CMakeLists.txt b/include/CMakeLists.txt
index 1c6790a..5a1b2cc 100644
--- a/include/CMakeLists.txt
+++ b/include/CMakeLists.txt
@@ -20,7 +20,7 @@
if (LIBCXX_INSTALL_HEADERS)
install(DIRECTORY .
- DESTINATION include/c++/v1
+ DESTINATION ${LIBCXX_INSTALL_PREFIX}include/c++/v1
COMPONENT cxx-headers
FILES_MATCHING
${LIBCXX_HEADER_PATTERN}
@@ -44,7 +44,7 @@
set(generated_config_deps generate_config_header)
# Install the generated header as __config.
install(FILES ${LIBCXX_BINARY_DIR}/__generated_config
- DESTINATION include/c++/v1
+ DESTINATION ${LIBCXX_INSTALL_PREFIX}include/c++/v1
PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
RENAME __config
COMPONENT cxx-headers)
diff --git a/include/__bsd_locale_defaults.h b/include/__bsd_locale_defaults.h
index f315ca2..cbc407d 100644
--- a/include/__bsd_locale_defaults.h
+++ b/include/__bsd_locale_defaults.h
@@ -15,6 +15,10 @@
#ifndef _LIBCPP_BSD_LOCALE_DEFAULTS_H
#define _LIBCPP_BSD_LOCALE_DEFAULTS_H
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
#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)
diff --git a/include/__bsd_locale_fallbacks.h b/include/__bsd_locale_fallbacks.h
index 9489452..5e9e094 100644
--- a/include/__bsd_locale_fallbacks.h
+++ b/include/__bsd_locale_fallbacks.h
@@ -18,6 +18,10 @@
#include <stdarg.h>
#include <memory>
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
_LIBCPP_BEGIN_NAMESPACE_STD
inline _LIBCPP_ALWAYS_INLINE
diff --git a/include/__config b/include/__config
index fc24a3b..d621723 100644
--- a/include/__config
+++ b/include/__config
@@ -33,7 +33,7 @@
#define _GNUC_VER_NEW 0
#endif
-#define _LIBCPP_VERSION 5000
+#define _LIBCPP_VERSION 6000
#ifndef _LIBCPP_ABI_VERSION
#define _LIBCPP_ABI_VERSION 1
@@ -55,11 +55,11 @@
#define _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
// Fix deque iterator type in order to support incomplete types.
#define _LIBCPP_ABI_INCOMPLETE_TYPES_IN_DEQUE
-// Fix undefined behavior in how std::list stores it's linked nodes.
+// Fix undefined behavior in how std::list stores its 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
-// Fix undefined behavior in how __hash_table stores it's pointer types
+// Fix undefined behavior in how __hash_table stores its pointer types.
#define _LIBCPP_ABI_FIX_UNORDERED_NODE_POINTER_UB
#define _LIBCPP_ABI_FORWARD_LIST_REMOVE_NODE_POINTER_UB
#define _LIBCPP_ABI_FIX_UNORDERED_CONTAINER_SIZE_TYPE
@@ -157,11 +157,21 @@
// FIXME: ABI detection should be done via compiler builtin macros. This
// is just a placeholder until Clang implements such macros. For now assume
-// that Windows compilers pretending to be MSVC++ target the microsoft ABI.
-#if defined(_WIN32) && defined(_MSC_VER)
+// that Windows compilers pretending to be MSVC++ target the Microsoft ABI,
+// and allow the user to explicitly specify the ABI to handle cases where this
+// heuristic falls short.
+#if defined(_LIBCPP_ABI_FORCE_ITANIUM) && defined(_LIBCPP_ABI_FORCE_MICROSOFT)
+# error "Only one of _LIBCPP_ABI_FORCE_ITANIUM and _LIBCPP_ABI_FORCE_MICROSOFT can be defined"
+#elif defined(_LIBCPP_ABI_FORCE_ITANIUM)
+# define _LIBCPP_ABI_ITANIUM
+#elif defined(_LIBCPP_ABI_FORCE_MICROSOFT)
# define _LIBCPP_ABI_MICROSOFT
#else
-# define _LIBCPP_ABI_ITANIUM
+# if defined(_WIN32) && defined(_MSC_VER)
+# define _LIBCPP_ABI_MICROSOFT
+# else
+# define _LIBCPP_ABI_ITANIUM
+# endif
#endif
// Need to detect which libc we're using if we're on Linux.
@@ -174,36 +184,30 @@
#ifdef __LITTLE_ENDIAN__
#if __LITTLE_ENDIAN__
-#define _LIBCPP_LITTLE_ENDIAN 1
-#define _LIBCPP_BIG_ENDIAN 0
+#define _LIBCPP_LITTLE_ENDIAN
#endif // __LITTLE_ENDIAN__
#endif // __LITTLE_ENDIAN__
#ifdef __BIG_ENDIAN__
#if __BIG_ENDIAN__
-#define _LIBCPP_LITTLE_ENDIAN 0
-#define _LIBCPP_BIG_ENDIAN 1
+#define _LIBCPP_BIG_ENDIAN
#endif // __BIG_ENDIAN__
#endif // __BIG_ENDIAN__
#ifdef __BYTE_ORDER__
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-#define _LIBCPP_LITTLE_ENDIAN 1
-#define _LIBCPP_BIG_ENDIAN 0
+#define _LIBCPP_LITTLE_ENDIAN
#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-#define _LIBCPP_LITTLE_ENDIAN 0
-#define _LIBCPP_BIG_ENDIAN 1
+#define _LIBCPP_BIG_ENDIAN
#endif // __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
#endif // __BYTE_ORDER__
#ifdef __FreeBSD__
# include <sys/endian.h>
# if _BYTE_ORDER == _LITTLE_ENDIAN
-# define _LIBCPP_LITTLE_ENDIAN 1
-# define _LIBCPP_BIG_ENDIAN 0
+# define _LIBCPP_LITTLE_ENDIAN
# else // _BYTE_ORDER == _LITTLE_ENDIAN
-# define _LIBCPP_LITTLE_ENDIAN 0
-# define _LIBCPP_BIG_ENDIAN 1
+# define _LIBCPP_BIG_ENDIAN
# endif // _BYTE_ORDER == _LITTLE_ENDIAN
# ifndef __LONG_LONG_SUPPORTED
# define _LIBCPP_HAS_NO_LONG_LONG
@@ -213,24 +217,22 @@
#ifdef __NetBSD__
# include <sys/endian.h>
# if _BYTE_ORDER == _LITTLE_ENDIAN
-# define _LIBCPP_LITTLE_ENDIAN 1
-# define _LIBCPP_BIG_ENDIAN 0
+# define _LIBCPP_LITTLE_ENDIAN
# else // _BYTE_ORDER == _LITTLE_ENDIAN
-# define _LIBCPP_LITTLE_ENDIAN 0
-# define _LIBCPP_BIG_ENDIAN 1
+# define _LIBCPP_BIG_ENDIAN
# endif // _BYTE_ORDER == _LITTLE_ENDIAN
# define _LIBCPP_HAS_QUICK_EXIT
#endif // __NetBSD__
#if defined(_WIN32)
# define _LIBCPP_WIN32API
-# define _LIBCPP_LITTLE_ENDIAN 1
-# define _LIBCPP_BIG_ENDIAN 0
+# define _LIBCPP_LITTLE_ENDIAN
# define _LIBCPP_SHORT_WCHAR 1
// Both MinGW and native MSVC provide a "MSVC"-like enviroment
# define _LIBCPP_MSVCRT_LIKE
-// If mingw not explicitly detected, assume using MS C runtime only.
-# ifndef __MINGW32__
+// If mingw not explicitly detected, assume using MS C runtime only if
+// a MS compatibility version is specified.
+# if defined(_MSC_VER) && !defined(__MINGW32__)
# define _LIBCPP_MSVCRT // Using Microsoft's C Runtime library
# endif
# if (defined(_M_AMD64) || defined(__x86_64__)) || (defined(_M_ARM) || defined(__arm__))
@@ -254,11 +256,9 @@
#ifdef __sun__
# include <sys/isa_defs.h>
# ifdef _LITTLE_ENDIAN
-# define _LIBCPP_LITTLE_ENDIAN 1
-# define _LIBCPP_BIG_ENDIAN 0
+# define _LIBCPP_LITTLE_ENDIAN
# else
-# define _LIBCPP_LITTLE_ENDIAN 0
-# define _LIBCPP_BIG_ENDIAN 1
+# define _LIBCPP_BIG_ENDIAN
# endif
#endif // __sun__
@@ -279,18 +279,16 @@
# define _LIBCPP_USING_DEV_RANDOM
#endif
-#if !defined(_LIBCPP_LITTLE_ENDIAN) || !defined(_LIBCPP_BIG_ENDIAN)
+#if !defined(_LIBCPP_LITTLE_ENDIAN) && !defined(_LIBCPP_BIG_ENDIAN)
# include <endian.h>
# if __BYTE_ORDER == __LITTLE_ENDIAN
-# define _LIBCPP_LITTLE_ENDIAN 1
-# define _LIBCPP_BIG_ENDIAN 0
+# define _LIBCPP_LITTLE_ENDIAN
# elif __BYTE_ORDER == __BIG_ENDIAN
-# define _LIBCPP_LITTLE_ENDIAN 0
-# define _LIBCPP_BIG_ENDIAN 1
+# define _LIBCPP_BIG_ENDIAN
# else // __BYTE_ORDER == __BIG_ENDIAN
# error unable to determine endian
# endif
-#endif // !defined(_LIBCPP_LITTLE_ENDIAN) || !defined(_LIBCPP_BIG_ENDIAN)
+#endif // !defined(_LIBCPP_LITTLE_ENDIAN) && !defined(_LIBCPP_BIG_ENDIAN)
#if __has_attribute(__no_sanitize__) && !defined(_LIBCPP_COMPILER_GCC)
#define _LIBCPP_NO_CFI __attribute__((__no_sanitize__("cfi")))
@@ -625,7 +623,6 @@
#define _LIBCPP_HIDDEN
#define _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
#define _LIBCPP_TEMPLATE_VIS
-#define _LIBCPP_FUNC_VIS_ONLY
#define _LIBCPP_ENUM_VIS
#if defined(_LIBCPP_COMPILER_MSVC)
@@ -684,10 +681,6 @@
# endif
#endif
-#ifndef _LIBCPP_FUNC_VIS_ONLY
-# define _LIBCPP_FUNC_VIS_ONLY _LIBCPP_FUNC_VIS
-#endif
-
#ifndef _LIBCPP_EXTERN_VIS
# define _LIBCPP_EXTERN_VIS
#endif
@@ -925,8 +918,10 @@
# define _LIBCPP_STD_VER 11
# elif __cplusplus <= 201402L
# define _LIBCPP_STD_VER 14
+# elif __cplusplus <= 201703L
+# define _LIBCPP_STD_VER 17
# else
-# define _LIBCPP_STD_VER 16 // current year, or date of c++17 ratification
+# define _LIBCPP_STD_VER 18 // current year, or date of c++2a ratification
# endif
#endif // _LIBCPP_STD_VER
@@ -1154,6 +1149,7 @@
__attribute__((availability(watchos,strict,introduced=3.0)))
#define _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS __attribute__((unavailable))
#define _LIBCPP_AVAILABILITY_BAD_ARRAY_LENGTH __attribute__((unavailable))
+#define _LIBCPP_AVAILABILITY_BAD_ANY_CAST __attribute__((unavailable))
#define _LIBCPP_AVAILABILITY_UNCAUGHT_EXCEPTIONS \
__attribute__((availability(macosx,strict,introduced=10.12))) \
__attribute__((availability(ios,strict,introduced=10.0))) \
@@ -1179,6 +1175,7 @@
#define _LIBCPP_AVAILABILITY_SHARED_MUTEX
#define _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS
#define _LIBCPP_AVAILABILITY_BAD_ARRAY_LENGTH
+#define _LIBCPP_AVAILABILITY_BAD_ANY_CAST
#define _LIBCPP_AVAILABILITY_UNCAUGHT_EXCEPTIONS
#define _LIBCPP_AVAILABILITY_SIZED_NEW_DELETE
#define _LIBCPP_AVAILABILITY_FUTURE_ERROR
@@ -1191,9 +1188,12 @@
#ifdef _LIBCPP_NO_EXCEPTIONS
#define _LIBCPP_AVAILABILITY_DYNARRAY
#define _LIBCPP_AVAILABILITY_FUTURE
+#define _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST
#else
#define _LIBCPP_AVAILABILITY_DYNARRAY _LIBCPP_AVAILABILITY_BAD_ARRAY_LENGTH
#define _LIBCPP_AVAILABILITY_FUTURE _LIBCPP_AVAILABILITY_FUTURE_ERROR
+#define _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST \
+ _LIBCPP_AVAILABILITY_BAD_ANY_CAST
#endif
// Availability of stream API in the dylib got dropped and re-added. The
@@ -1202,9 +1202,9 @@
// availability(ios,introduced=7.0)
#if defined(_LIBCPP_USE_AVAILABILITY_APPLE) && \
((defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && \
- __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ <= 1090) || \
+ __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 1090) || \
(defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && \
- __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ <= 70000))
+ __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 70000))
#define _LIBCPP_AVAILABILITY_NO_STREAMS_EXTERN_TEMPLATE
#endif
diff --git a/include/__config_site.in b/include/__config_site.in
index 667b4e9..86418a3 100644
--- a/include/__config_site.in
+++ b/include/__config_site.in
@@ -12,6 +12,8 @@
#cmakedefine _LIBCPP_ABI_VERSION @_LIBCPP_ABI_VERSION@
#cmakedefine _LIBCPP_ABI_UNSTABLE
+#cmakedefine _LIBCPP_ABI_FORCE_ITANIUM
+#cmakedefine _LIBCPP_ABI_FORCE_MICROSOFT
#cmakedefine _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
#cmakedefine _LIBCPP_HAS_NO_STDIN
#cmakedefine _LIBCPP_HAS_NO_STDOUT
@@ -23,5 +25,8 @@
#cmakedefine _LIBCPP_HAS_THREAD_API_EXTERNAL
#cmakedefine _LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL
#cmakedefine _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS
+#cmakedefine _LIBCPP_NO_VCRUNTIME
+
+@_LIBCPP_ABI_DEFINES@
#endif // _LIBCPP_CONFIG_SITE
diff --git a/include/__libcpp_version b/include/__libcpp_version
index e9c02da..a77fd92 100644
--- a/include/__libcpp_version
+++ b/include/__libcpp_version
@@ -1 +1 @@
-5000
+6000
diff --git a/include/__locale b/include/__locale
index 7668422..91ed9e7 100644
--- a/include/__locale
+++ b/include/__locale
@@ -34,7 +34,7 @@
# include <support/solaris/xlocale.h>
#elif defined(_NEWLIB_VERSION)
# include <support/newlib/xlocale.h>
-#elif (defined(__GLIBC__) || defined(__APPLE__) || defined(__FreeBSD__) \
+#elif (defined(__APPLE__) || defined(__FreeBSD__) \
|| defined(__EMSCRIPTEN__) || defined(__IBMCPP__))
# include <xlocale.h>
#elif defined(__Fuchsia__)
diff --git a/include/__tree b/include/__tree
index 792870a..3ccfcb7 100644
--- a/include/__tree
+++ b/include/__tree
@@ -84,7 +84,7 @@
return __x == __x->__parent_->__left_;
}
-// Determintes if the subtree rooted at __x is a proper red black subtree. If
+// Determines if the subtree rooted at __x is a proper red black subtree. If
// __x is a proper subtree, returns the black height (null counts as 1). If
// __x is an improper subtree, returns 0.
template <class _NodePtr>
@@ -119,7 +119,7 @@
return __h + __x->__is_black_; // return black height of this node
}
-// Determintes if the red black tree rooted at __root is a proper red black tree.
+// Determines if the red black tree rooted at __root is a proper red black tree.
// __root == nullptr is a proper tree. Returns true is __root is a proper
// red black tree, else returns false.
template <class _NodePtr>
diff --git a/include/algorithm b/include/algorithm
index 9fe0361..282083a 100644
--- a/include/algorithm
+++ b/include/algorithm
@@ -734,15 +734,15 @@
};
template <class _Predicate>
-class __negate
+class __invert // invert the sense of a comparison
{
private:
_Predicate __p_;
public:
- _LIBCPP_INLINE_VISIBILITY __negate() {}
+ _LIBCPP_INLINE_VISIBILITY __invert() {}
_LIBCPP_INLINE_VISIBILITY
- explicit __negate(_Predicate __p) : __p_(__p) {}
+ explicit __invert(_Predicate __p) : __p_(__p) {}
template <class _T1>
_LIBCPP_INLINE_VISIBILITY
@@ -750,7 +750,7 @@
template <class _T1, class _T2>
_LIBCPP_INLINE_VISIBILITY
- bool operator()(const _T1& __x, const _T2& __y) {return !__p_(__x, __y);}
+ bool operator()(const _T1& __x, const _T2& __y) {return __p_(__y, __x);}
};
#ifdef _LIBCPP_DEBUG
@@ -3013,6 +3013,7 @@
_UIntType
__independent_bits_engine<_Engine, _UIntType>::__eval(true_type)
{
+ const size_t _WRt = numeric_limits<result_type>::digits;
result_type _Sp = 0;
for (size_t __k = 0; __k < __n0_; ++__k)
{
@@ -3021,7 +3022,7 @@
{
__u = __e_() - _Engine::min();
} while (__u >= __y0_);
- if (__w0_ < _WDt)
+ if (__w0_ < _WRt)
_Sp <<= __w0_;
else
_Sp = 0;
@@ -3034,7 +3035,7 @@
{
__u = __e_() - _Engine::min();
} while (__u >= __y1_);
- if (__w0_ < _WDt - 1)
+ if (__w0_ < _WRt - 1)
_Sp <<= __w0_ + 1;
else
_Sp = 0;
@@ -4234,10 +4235,6 @@
_VSTD::sort<_Tp*, _Comp_ref>(__first.base(), __last.base(), __comp);
}
-#ifdef _LIBCPP_MSVC
-#pragma warning( push )
-#pragma warning( disable: 4231)
-#endif // _LIBCPP_MSVC
_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<char>&, char*>(char*, char*, __less<char>&))
_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<wchar_t>&, wchar_t*>(wchar_t*, wchar_t*, __less<wchar_t>&))
_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<signed char>&, signed char*>(signed char*, signed char*, __less<signed char>&))
@@ -4271,9 +4268,6 @@
_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<long double>&, long double*>(long double*, long double*, __less<long double>&))
_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS unsigned __sort5<__less<long double>&, long double*>(long double*, long double*, long double*, long double*, long double*, __less<long double>&))
-#ifdef _LIBCPP_MSVC
-#pragma warning( pop )
-#endif // _LIBCPP_MSVC
// lower_bound
@@ -4574,7 +4568,7 @@
typedef reverse_iterator<value_type*> _Rv;
__half_inplace_merge(_Rv(__p), _Rv(__buff),
_RBi(__middle), _RBi(__first),
- _RBi(__last), __negate<_Compare>(__comp));
+ _RBi(__last), __invert<_Compare>(__comp));
}
}
diff --git a/include/chrono b/include/chrono
index 4b793c7..c69e88a 100644
--- a/include/chrono
+++ b/include/chrono
@@ -283,18 +283,18 @@
} // chrono
-constexpr chrono::hours operator "" h(unsigned long long); // C++14
-constexpr chrono::duration<unspecified , ratio<3600,1>> operator "" h(long double); // C++14
-constexpr chrono::minutes operator "" min(unsigned long long); // C++14
-constexpr chrono::duration<unspecified , ratio<60,1>> operator "" min(long double); // C++14
-constexpr chrono::seconds operator "" s(unsigned long long); // C++14
-constexpr chrono::duration<unspecified > operator "" s(long double); // C++14
-constexpr chrono::milliseconds operator "" ms(unsigned long long); // C++14
-constexpr chrono::duration<unspecified , milli> operator "" ms(long double); // C++14
-constexpr chrono::microseconds operator "" us(unsigned long long); // C++14
-constexpr chrono::duration<unspecified , micro> operator "" us(long double); // C++14
-constexpr chrono::nanoseconds operator "" ns(unsigned long long); // C++14
-constexpr chrono::duration<unspecified , nano> operator "" ns(long double); // C++14
+constexpr chrono::hours operator ""h(unsigned long long); // C++14
+constexpr chrono::duration<unspecified , ratio<3600,1>> operator ""h(long double); // C++14
+constexpr chrono::minutes operator ""min(unsigned long long); // C++14
+constexpr chrono::duration<unspecified , ratio<60,1>> operator ""min(long double); // C++14
+constexpr chrono::seconds operator ""s(unsigned long long); // C++14
+constexpr chrono::duration<unspecified > operator ""s(long double); // C++14
+constexpr chrono::milliseconds operator ""ms(unsigned long long); // C++14
+constexpr chrono::duration<unspecified , milli> operator ""ms(long double); // C++14
+constexpr chrono::microseconds operator ""us(unsigned long long); // C++14
+constexpr chrono::duration<unspecified , micro> operator ""us(long double); // C++14
+constexpr chrono::nanoseconds operator ""ns(unsigned long long); // C++14
+constexpr chrono::duration<unspecified , nano> operator ""ns(long double); // C++14
} // std
*/
@@ -1087,67 +1087,67 @@
inline namespace chrono_literals
{
- constexpr chrono::hours operator"" h(unsigned long long __h)
+ constexpr chrono::hours operator""h(unsigned long long __h)
{
return chrono::hours(static_cast<chrono::hours::rep>(__h));
}
- constexpr chrono::duration<long double, ratio<3600,1>> operator"" h(long double __h)
+ constexpr chrono::duration<long double, ratio<3600,1>> operator""h(long double __h)
{
return chrono::duration<long double, ratio<3600,1>>(__h);
}
- constexpr chrono::minutes operator"" min(unsigned long long __m)
+ constexpr chrono::minutes operator""min(unsigned long long __m)
{
return chrono::minutes(static_cast<chrono::minutes::rep>(__m));
}
- constexpr chrono::duration<long double, ratio<60,1>> operator"" min(long double __m)
+ constexpr chrono::duration<long double, ratio<60,1>> operator""min(long double __m)
{
return chrono::duration<long double, ratio<60,1>> (__m);
}
- constexpr chrono::seconds operator"" s(unsigned long long __s)
+ constexpr chrono::seconds operator""s(unsigned long long __s)
{
return chrono::seconds(static_cast<chrono::seconds::rep>(__s));
}
- constexpr chrono::duration<long double> operator"" s(long double __s)
+ constexpr chrono::duration<long double> operator""s(long double __s)
{
return chrono::duration<long double> (__s);
}
- constexpr chrono::milliseconds operator"" ms(unsigned long long __ms)
+ constexpr chrono::milliseconds operator""ms(unsigned long long __ms)
{
return chrono::milliseconds(static_cast<chrono::milliseconds::rep>(__ms));
}
- constexpr chrono::duration<long double, milli> operator"" ms(long double __ms)
+ constexpr chrono::duration<long double, milli> operator""ms(long double __ms)
{
return chrono::duration<long double, milli>(__ms);
}
- constexpr chrono::microseconds operator"" us(unsigned long long __us)
+ constexpr chrono::microseconds operator""us(unsigned long long __us)
{
return chrono::microseconds(static_cast<chrono::microseconds::rep>(__us));
}
- constexpr chrono::duration<long double, micro> operator"" us(long double __us)
+ constexpr chrono::duration<long double, micro> operator""us(long double __us)
{
return chrono::duration<long double, micro> (__us);
}
- constexpr chrono::nanoseconds operator"" ns(unsigned long long __ns)
+ constexpr chrono::nanoseconds operator""ns(unsigned long long __ns)
{
return chrono::nanoseconds(static_cast<chrono::nanoseconds::rep>(__ns));
}
- constexpr chrono::duration<long double, nano> operator"" ns(long double __ns)
+ constexpr chrono::duration<long double, nano> operator""ns(long double __ns)
{
return chrono::duration<long double, nano> (__ns);
}
diff --git a/include/cmath b/include/cmath
index b41f247..917928a 100644
--- a/include/cmath
+++ b/include/cmath
@@ -549,7 +549,7 @@
template <class _A1>
_LIBCPP_ALWAYS_INLINE
_LIBCPP_CONSTEXPR typename enable_if<is_floating_point<_A1>::value, bool>::type
-__libcpp_isnan(_A1 __lcpp_x) _NOEXCEPT
+__libcpp_isnan_or_builtin(_A1 __lcpp_x) _NOEXCEPT
{
#if __has_builtin(__builtin_isnan)
return __builtin_isnan(__lcpp_x);
@@ -561,7 +561,7 @@
template <class _A1>
_LIBCPP_ALWAYS_INLINE
_LIBCPP_CONSTEXPR typename enable_if<!is_floating_point<_A1>::value, bool>::type
-__libcpp_isnan(_A1 __lcpp_x) _NOEXCEPT
+__libcpp_isnan_or_builtin(_A1 __lcpp_x) _NOEXCEPT
{
return isnan(__lcpp_x);
}
@@ -569,7 +569,7 @@
template <class _A1>
_LIBCPP_ALWAYS_INLINE
_LIBCPP_CONSTEXPR typename enable_if<is_floating_point<_A1>::value, bool>::type
-__libcpp_isinf(_A1 __lcpp_x) _NOEXCEPT
+__libcpp_isinf_or_builtin(_A1 __lcpp_x) _NOEXCEPT
{
#if __has_builtin(__builtin_isinf)
return __builtin_isinf(__lcpp_x);
@@ -581,7 +581,7 @@
template <class _A1>
_LIBCPP_ALWAYS_INLINE
_LIBCPP_CONSTEXPR typename enable_if<!is_floating_point<_A1>::value, bool>::type
-__libcpp_isinf(_A1 __lcpp_x) _NOEXCEPT
+__libcpp_isinf_or_builtin(_A1 __lcpp_x) _NOEXCEPT
{
return isinf(__lcpp_x);
}
@@ -589,7 +589,7 @@
template <class _A1>
_LIBCPP_ALWAYS_INLINE
_LIBCPP_CONSTEXPR typename enable_if<is_floating_point<_A1>::value, bool>::type
-__libcpp_isfinite(_A1 __lcpp_x) _NOEXCEPT
+__libcpp_isfinite_or_builtin(_A1 __lcpp_x) _NOEXCEPT
{
#if __has_builtin(__builtin_isfinite)
return __builtin_isfinite(__lcpp_x);
@@ -601,7 +601,7 @@
template <class _A1>
_LIBCPP_ALWAYS_INLINE
_LIBCPP_CONSTEXPR typename enable_if<!is_floating_point<_A1>::value, bool>::type
-__libcpp_isfinite(_A1 __lcpp_x) _NOEXCEPT
+__libcpp_isfinite_or_builtin(_A1 __lcpp_x) _NOEXCEPT
{
return isfinite(__lcpp_x);
}
diff --git a/include/complex b/include/complex
index d41971b..41a47cf 100644
--- a/include/complex
+++ b/include/complex
@@ -599,39 +599,39 @@
_Tp __bc = __b * __c;
_Tp __x = __ac - __bd;
_Tp __y = __ad + __bc;
- if (__libcpp_isnan(__x) && __libcpp_isnan(__y))
+ if (__libcpp_isnan_or_builtin(__x) && __libcpp_isnan_or_builtin(__y))
{
bool __recalc = false;
- if (__libcpp_isinf(__a) || __libcpp_isinf(__b))
+ if (__libcpp_isinf_or_builtin(__a) || __libcpp_isinf_or_builtin(__b))
{
- __a = copysign(__libcpp_isinf(__a) ? _Tp(1) : _Tp(0), __a);
- __b = copysign(__libcpp_isinf(__b) ? _Tp(1) : _Tp(0), __b);
- if (__libcpp_isnan(__c))
+ __a = copysign(__libcpp_isinf_or_builtin(__a) ? _Tp(1) : _Tp(0), __a);
+ __b = copysign(__libcpp_isinf_or_builtin(__b) ? _Tp(1) : _Tp(0), __b);
+ if (__libcpp_isnan_or_builtin(__c))
__c = copysign(_Tp(0), __c);
- if (__libcpp_isnan(__d))
+ if (__libcpp_isnan_or_builtin(__d))
__d = copysign(_Tp(0), __d);
__recalc = true;
}
- if (__libcpp_isinf(__c) || __libcpp_isinf(__d))
+ if (__libcpp_isinf_or_builtin(__c) || __libcpp_isinf_or_builtin(__d))
{
- __c = copysign(__libcpp_isinf(__c) ? _Tp(1) : _Tp(0), __c);
- __d = copysign(__libcpp_isinf(__d) ? _Tp(1) : _Tp(0), __d);
- if (__libcpp_isnan(__a))
+ __c = copysign(__libcpp_isinf_or_builtin(__c) ? _Tp(1) : _Tp(0), __c);
+ __d = copysign(__libcpp_isinf_or_builtin(__d) ? _Tp(1) : _Tp(0), __d);
+ if (__libcpp_isnan_or_builtin(__a))
__a = copysign(_Tp(0), __a);
- if (__libcpp_isnan(__b))
+ if (__libcpp_isnan_or_builtin(__b))
__b = copysign(_Tp(0), __b);
__recalc = true;
}
- if (!__recalc && (__libcpp_isinf(__ac) || __libcpp_isinf(__bd) ||
- __libcpp_isinf(__ad) || __libcpp_isinf(__bc)))
+ if (!__recalc && (__libcpp_isinf_or_builtin(__ac) || __libcpp_isinf_or_builtin(__bd) ||
+ __libcpp_isinf_or_builtin(__ad) || __libcpp_isinf_or_builtin(__bc)))
{
- if (__libcpp_isnan(__a))
+ if (__libcpp_isnan_or_builtin(__a))
__a = copysign(_Tp(0), __a);
- if (__libcpp_isnan(__b))
+ if (__libcpp_isnan_or_builtin(__b))
__b = copysign(_Tp(0), __b);
- if (__libcpp_isnan(__c))
+ if (__libcpp_isnan_or_builtin(__c))
__c = copysign(_Tp(0), __c);
- if (__libcpp_isnan(__d))
+ if (__libcpp_isnan_or_builtin(__d))
__d = copysign(_Tp(0), __d);
__recalc = true;
}
@@ -674,7 +674,7 @@
_Tp __c = __w.real();
_Tp __d = __w.imag();
_Tp __logbw = logb(fmax(fabs(__c), fabs(__d)));
- if (__libcpp_isfinite(__logbw))
+ if (__libcpp_isfinite_or_builtin(__logbw))
{
__ilogbw = static_cast<int>(__logbw);
__c = scalbn(__c, -__ilogbw);
@@ -683,24 +683,24 @@
_Tp __denom = __c * __c + __d * __d;
_Tp __x = scalbn((__a * __c + __b * __d) / __denom, -__ilogbw);
_Tp __y = scalbn((__b * __c - __a * __d) / __denom, -__ilogbw);
- if (__libcpp_isnan(__x) && __libcpp_isnan(__y))
+ if (__libcpp_isnan_or_builtin(__x) && __libcpp_isnan_or_builtin(__y))
{
- if ((__denom == _Tp(0)) && (!__libcpp_isnan(__a) || !__libcpp_isnan(__b)))
+ if ((__denom == _Tp(0)) && (!__libcpp_isnan_or_builtin(__a) || !__libcpp_isnan_or_builtin(__b)))
{
__x = copysign(_Tp(INFINITY), __c) * __a;
__y = copysign(_Tp(INFINITY), __c) * __b;
}
- else if ((__libcpp_isinf(__a) || __libcpp_isinf(__b)) && __libcpp_isfinite(__c) && __libcpp_isfinite(__d))
+ else if ((__libcpp_isinf_or_builtin(__a) || __libcpp_isinf_or_builtin(__b)) && __libcpp_isfinite_or_builtin(__c) && __libcpp_isfinite_or_builtin(__d))
{
- __a = copysign(__libcpp_isinf(__a) ? _Tp(1) : _Tp(0), __a);
- __b = copysign(__libcpp_isinf(__b) ? _Tp(1) : _Tp(0), __b);
+ __a = copysign(__libcpp_isinf_or_builtin(__a) ? _Tp(1) : _Tp(0), __a);
+ __b = copysign(__libcpp_isinf_or_builtin(__b) ? _Tp(1) : _Tp(0), __b);
__x = _Tp(INFINITY) * (__a * __c + __b * __d);
__y = _Tp(INFINITY) * (__b * __c - __a * __d);
}
- else if (__libcpp_isinf(__logbw) && __logbw > _Tp(0) && __libcpp_isfinite(__a) && __libcpp_isfinite(__b))
+ else if (__libcpp_isinf_or_builtin(__logbw) && __logbw > _Tp(0) && __libcpp_isfinite_or_builtin(__a) && __libcpp_isfinite_or_builtin(__b))
{
- __c = copysign(__libcpp_isinf(__c) ? _Tp(1) : _Tp(0), __c);
- __d = copysign(__libcpp_isinf(__d) ? _Tp(1) : _Tp(0), __d);
+ __c = copysign(__libcpp_isinf_or_builtin(__c) ? _Tp(1) : _Tp(0), __c);
+ __d = copysign(__libcpp_isinf_or_builtin(__d) ? _Tp(1) : _Tp(0), __d);
__x = _Tp(0) * (__a * __c + __b * __d);
__y = _Tp(0) * (__b * __c - __a * __d);
}
@@ -910,9 +910,9 @@
_Tp
norm(const complex<_Tp>& __c)
{
- if (__libcpp_isinf(__c.real()))
+ if (__libcpp_isinf_or_builtin(__c.real()))
return abs(__c.real());
- if (__libcpp_isinf(__c.imag()))
+ if (__libcpp_isinf_or_builtin(__c.imag()))
return abs(__c.imag());
return __c.real() * __c.real() + __c.imag() * __c.imag();
}
@@ -955,7 +955,7 @@
proj(const complex<_Tp>& __c)
{
std::complex<_Tp> __r = __c;
- if (__libcpp_isinf(__c.real()) || __libcpp_isinf(__c.imag()))
+ if (__libcpp_isinf_or_builtin(__c.real()) || __libcpp_isinf_or_builtin(__c.imag()))
__r = complex<_Tp>(INFINITY, copysign(_Tp(0), __c.imag()));
return __r;
}
@@ -969,7 +969,7 @@
>::type
proj(_Tp __re)
{
- if (__libcpp_isinf(__re))
+ if (__libcpp_isinf_or_builtin(__re))
__re = abs(__re);
return complex<_Tp>(__re);
}
@@ -993,25 +993,25 @@
complex<_Tp>
polar(const _Tp& __rho, const _Tp& __theta = _Tp(0))
{
- if (__libcpp_isnan(__rho) || signbit(__rho))
+ if (__libcpp_isnan_or_builtin(__rho) || signbit(__rho))
return complex<_Tp>(_Tp(NAN), _Tp(NAN));
- if (__libcpp_isnan(__theta))
+ if (__libcpp_isnan_or_builtin(__theta))
{
- if (__libcpp_isinf(__rho))
+ if (__libcpp_isinf_or_builtin(__rho))
return complex<_Tp>(__rho, __theta);
return complex<_Tp>(__theta, __theta);
}
- if (__libcpp_isinf(__theta))
+ if (__libcpp_isinf_or_builtin(__theta))
{
- if (__libcpp_isinf(__rho))
+ if (__libcpp_isinf_or_builtin(__rho))
return complex<_Tp>(__rho, _Tp(NAN));
return complex<_Tp>(_Tp(NAN), _Tp(NAN));
}
_Tp __x = __rho * cos(__theta);
- if (__libcpp_isnan(__x))
+ if (__libcpp_isnan_or_builtin(__x))
__x = 0;
_Tp __y = __rho * sin(__theta);
- if (__libcpp_isnan(__y))
+ if (__libcpp_isnan_or_builtin(__y))
__y = 0;
return complex<_Tp>(__x, __y);
}
@@ -1042,13 +1042,13 @@
complex<_Tp>
sqrt(const complex<_Tp>& __x)
{
- if (__libcpp_isinf(__x.imag()))
+ if (__libcpp_isinf_or_builtin(__x.imag()))
return complex<_Tp>(_Tp(INFINITY), __x.imag());
- if (__libcpp_isinf(__x.real()))
+ if (__libcpp_isinf_or_builtin(__x.real()))
{
if (__x.real() > _Tp(0))
- return complex<_Tp>(__x.real(), __libcpp_isnan(__x.imag()) ? __x.imag() : copysign(_Tp(0), __x.imag()));
- return complex<_Tp>(__libcpp_isnan(__x.imag()) ? __x.imag() : _Tp(0), copysign(__x.real(), __x.imag()));
+ return complex<_Tp>(__x.real(), __libcpp_isnan_or_builtin(__x.imag()) ? __x.imag() : copysign(_Tp(0), __x.imag()));
+ return complex<_Tp>(__libcpp_isnan_or_builtin(__x.imag()) ? __x.imag() : _Tp(0), copysign(__x.real(), __x.imag()));
}
return polar(sqrt(abs(__x)), arg(__x) / _Tp(2));
}
@@ -1060,21 +1060,21 @@
exp(const complex<_Tp>& __x)
{
_Tp __i = __x.imag();
- if (__libcpp_isinf(__x.real()))
+ if (__libcpp_isinf_or_builtin(__x.real()))
{
if (__x.real() < _Tp(0))
{
- if (!__libcpp_isfinite(__i))
+ if (!__libcpp_isfinite_or_builtin(__i))
__i = _Tp(1);
}
- else if (__i == 0 || !__libcpp_isfinite(__i))
+ else if (__i == 0 || !__libcpp_isfinite_or_builtin(__i))
{
- if (__libcpp_isinf(__i))
+ if (__libcpp_isinf_or_builtin(__i))
__i = _Tp(NAN);
return complex<_Tp>(__x.real(), __i);
}
}
- else if (__libcpp_isnan(__x.real()) && __x.imag() == 0)
+ else if (__libcpp_isnan_or_builtin(__x.real()) && __x.imag() == 0)
return __x;
_Tp __e = exp(__x.real());
return complex<_Tp>(__e * cos(__i), __e * sin(__i));
@@ -1132,23 +1132,23 @@
asinh(const complex<_Tp>& __x)
{
const _Tp __pi(atan2(+0., -0.));
- if (__libcpp_isinf(__x.real()))
+ if (__libcpp_isinf_or_builtin(__x.real()))
{
- if (__libcpp_isnan(__x.imag()))
+ if (__libcpp_isnan_or_builtin(__x.imag()))
return __x;
- if (__libcpp_isinf(__x.imag()))
+ if (__libcpp_isinf_or_builtin(__x.imag()))
return complex<_Tp>(__x.real(), copysign(__pi * _Tp(0.25), __x.imag()));
return complex<_Tp>(__x.real(), copysign(_Tp(0), __x.imag()));
}
- if (__libcpp_isnan(__x.real()))
+ if (__libcpp_isnan_or_builtin(__x.real()))
{
- if (__libcpp_isinf(__x.imag()))
+ if (__libcpp_isinf_or_builtin(__x.imag()))
return complex<_Tp>(__x.imag(), __x.real());
if (__x.imag() == 0)
return __x;
return complex<_Tp>(__x.real(), __x.real());
}
- if (__libcpp_isinf(__x.imag()))
+ if (__libcpp_isinf_or_builtin(__x.imag()))
return complex<_Tp>(copysign(__x.imag(), __x.real()), copysign(__pi/_Tp(2), __x.imag()));
complex<_Tp> __z = log(__x + sqrt(pow(__x, _Tp(2)) + _Tp(1)));
return complex<_Tp>(copysign(__z.real(), __x.real()), copysign(__z.imag(), __x.imag()));
@@ -1161,11 +1161,11 @@
acosh(const complex<_Tp>& __x)
{
const _Tp __pi(atan2(+0., -0.));
- if (__libcpp_isinf(__x.real()))
+ if (__libcpp_isinf_or_builtin(__x.real()))
{
- if (__libcpp_isnan(__x.imag()))
+ if (__libcpp_isnan_or_builtin(__x.imag()))
return complex<_Tp>(abs(__x.real()), __x.imag());
- if (__libcpp_isinf(__x.imag()))
+ if (__libcpp_isinf_or_builtin(__x.imag()))
{
if (__x.real() > 0)
return complex<_Tp>(__x.real(), copysign(__pi * _Tp(0.25), __x.imag()));
@@ -1176,13 +1176,13 @@
return complex<_Tp>(-__x.real(), copysign(__pi, __x.imag()));
return complex<_Tp>(__x.real(), copysign(_Tp(0), __x.imag()));
}
- if (__libcpp_isnan(__x.real()))
+ if (__libcpp_isnan_or_builtin(__x.real()))
{
- if (__libcpp_isinf(__x.imag()))
+ if (__libcpp_isinf_or_builtin(__x.imag()))
return complex<_Tp>(abs(__x.imag()), __x.real());
return complex<_Tp>(__x.real(), __x.real());
}
- if (__libcpp_isinf(__x.imag()))
+ if (__libcpp_isinf_or_builtin(__x.imag()))
return complex<_Tp>(abs(__x.imag()), copysign(__pi/_Tp(2), __x.imag()));
complex<_Tp> __z = log(__x + sqrt(pow(__x, _Tp(2)) - _Tp(1)));
return complex<_Tp>(copysign(__z.real(), _Tp(0)), copysign(__z.imag(), __x.imag()));
@@ -1195,21 +1195,21 @@
atanh(const complex<_Tp>& __x)
{
const _Tp __pi(atan2(+0., -0.));
- if (__libcpp_isinf(__x.imag()))
+ if (__libcpp_isinf_or_builtin(__x.imag()))
{
return complex<_Tp>(copysign(_Tp(0), __x.real()), copysign(__pi/_Tp(2), __x.imag()));
}
- if (__libcpp_isnan(__x.imag()))
+ if (__libcpp_isnan_or_builtin(__x.imag()))
{
- if (__libcpp_isinf(__x.real()) || __x.real() == 0)
+ if (__libcpp_isinf_or_builtin(__x.real()) || __x.real() == 0)
return complex<_Tp>(copysign(_Tp(0), __x.real()), __x.imag());
return complex<_Tp>(__x.imag(), __x.imag());
}
- if (__libcpp_isnan(__x.real()))
+ if (__libcpp_isnan_or_builtin(__x.real()))
{
return complex<_Tp>(__x.real(), __x.real());
}
- if (__libcpp_isinf(__x.real()))
+ if (__libcpp_isinf_or_builtin(__x.real()))
{
return complex<_Tp>(copysign(_Tp(0), __x.real()), copysign(__pi/_Tp(2), __x.imag()));
}
@@ -1227,11 +1227,11 @@
complex<_Tp>
sinh(const complex<_Tp>& __x)
{
- if (__libcpp_isinf(__x.real()) && !__libcpp_isfinite(__x.imag()))
+ if (__libcpp_isinf_or_builtin(__x.real()) && !__libcpp_isfinite_or_builtin(__x.imag()))
return complex<_Tp>(__x.real(), _Tp(NAN));
- if (__x.real() == 0 && !__libcpp_isfinite(__x.imag()))
+ if (__x.real() == 0 && !__libcpp_isfinite_or_builtin(__x.imag()))
return complex<_Tp>(__x.real(), _Tp(NAN));
- if (__x.imag() == 0 && !__libcpp_isfinite(__x.real()))
+ if (__x.imag() == 0 && !__libcpp_isfinite_or_builtin(__x.real()))
return __x;
return complex<_Tp>(sinh(__x.real()) * cos(__x.imag()), cosh(__x.real()) * sin(__x.imag()));
}
@@ -1242,13 +1242,13 @@
complex<_Tp>
cosh(const complex<_Tp>& __x)
{
- if (__libcpp_isinf(__x.real()) && !__libcpp_isfinite(__x.imag()))
+ if (__libcpp_isinf_or_builtin(__x.real()) && !__libcpp_isfinite_or_builtin(__x.imag()))
return complex<_Tp>(abs(__x.real()), _Tp(NAN));
- if (__x.real() == 0 && !__libcpp_isfinite(__x.imag()))
+ if (__x.real() == 0 && !__libcpp_isfinite_or_builtin(__x.imag()))
return complex<_Tp>(_Tp(NAN), __x.real());
if (__x.real() == 0 && __x.imag() == 0)
return complex<_Tp>(_Tp(1), __x.imag());
- if (__x.imag() == 0 && !__libcpp_isfinite(__x.real()))
+ if (__x.imag() == 0 && !__libcpp_isfinite_or_builtin(__x.real()))
return complex<_Tp>(abs(__x.real()), __x.imag());
return complex<_Tp>(cosh(__x.real()) * cos(__x.imag()), sinh(__x.real()) * sin(__x.imag()));
}
@@ -1259,19 +1259,19 @@
complex<_Tp>
tanh(const complex<_Tp>& __x)
{
- if (__libcpp_isinf(__x.real()))
+ if (__libcpp_isinf_or_builtin(__x.real()))
{
- if (!__libcpp_isfinite(__x.imag()))
+ if (!__libcpp_isfinite_or_builtin(__x.imag()))
return complex<_Tp>(_Tp(1), _Tp(0));
return complex<_Tp>(_Tp(1), copysign(_Tp(0), sin(_Tp(2) * __x.imag())));
}
- if (__libcpp_isnan(__x.real()) && __x.imag() == 0)
+ if (__libcpp_isnan_or_builtin(__x.real()) && __x.imag() == 0)
return __x;
_Tp __2r(_Tp(2) * __x.real());
_Tp __2i(_Tp(2) * __x.imag());
_Tp __d(cosh(__2r) + cos(__2i));
_Tp __2rsh(sinh(__2r));
- if (__libcpp_isinf(__2rsh) && __libcpp_isinf(__d))
+ if (__libcpp_isinf_or_builtin(__2rsh) && __libcpp_isinf_or_builtin(__d))
return complex<_Tp>(__2rsh > _Tp(0) ? _Tp(1) : _Tp(-1),
__2i > _Tp(0) ? _Tp(0) : _Tp(-0.));
return complex<_Tp>(__2rsh/__d, sin(__2i)/__d);
@@ -1294,11 +1294,11 @@
acos(const complex<_Tp>& __x)
{
const _Tp __pi(atan2(+0., -0.));
- if (__libcpp_isinf(__x.real()))
+ if (__libcpp_isinf_or_builtin(__x.real()))
{
- if (__libcpp_isnan(__x.imag()))
+ if (__libcpp_isnan_or_builtin(__x.imag()))
return complex<_Tp>(__x.imag(), __x.real());
- if (__libcpp_isinf(__x.imag()))
+ if (__libcpp_isinf_or_builtin(__x.imag()))
{
if (__x.real() < _Tp(0))
return complex<_Tp>(_Tp(0.75) * __pi, -__x.imag());
@@ -1308,13 +1308,13 @@
return complex<_Tp>(__pi, signbit(__x.imag()) ? -__x.real() : __x.real());
return complex<_Tp>(_Tp(0), signbit(__x.imag()) ? __x.real() : -__x.real());
}
- if (__libcpp_isnan(__x.real()))
+ if (__libcpp_isnan_or_builtin(__x.real()))
{
- if (__libcpp_isinf(__x.imag()))
+ if (__libcpp_isinf_or_builtin(__x.imag()))
return complex<_Tp>(__x.real(), -__x.imag());
return complex<_Tp>(__x.real(), __x.real());
}
- if (__libcpp_isinf(__x.imag()))
+ if (__libcpp_isinf_or_builtin(__x.imag()))
return complex<_Tp>(__pi/_Tp(2), -__x.imag());
if (__x.real() == 0 && (__x.imag() == 0 || isnan(__x.imag())))
return complex<_Tp>(__pi/_Tp(2), -__x.imag());
diff --git a/include/deque b/include/deque
index f795b48..fee7561 100644
--- a/include/deque
+++ b/include/deque
@@ -1356,7 +1356,6 @@
iterator insert(const_iterator __p, initializer_list<value_type> __il)
{return insert(__p, __il.begin(), __il.end());}
#endif // _LIBCPP_CXX03_LANG
-
iterator insert(const_iterator __p, const value_type& __v);
iterator insert(const_iterator __p, size_type __n, const value_type& __v);
template <class _InputIter>
@@ -2224,7 +2223,11 @@
!__is_forward_iterator<_InpIter>::value>::type*)
{
for (; __f != __l; ++__f)
+#ifdef _LIBCPP_CXX03_LANG
push_back(*__f);
+#else
+ emplace_back(*__f);
+#endif
}
template <class _Tp, class _Allocator>
diff --git a/include/exception b/include/exception
index ca2eaf5..79bd6ac 100644
--- a/include/exception
+++ b/include/exception
@@ -82,7 +82,7 @@
#include <cstdlib>
#include <type_traits>
-#if defined(_LIBCPP_ABI_MICROSOFT)
+#if defined(_LIBCPP_ABI_MICROSOFT) && !defined(_LIBCPP_NO_VCRUNTIME)
#include <vcruntime_exception.h>
#endif
@@ -93,7 +93,7 @@
namespace std // purposefully not using versioning namespace
{
-#if !defined(_LIBCPP_ABI_MICROSOFT)
+#if !defined(_LIBCPP_ABI_MICROSOFT) || defined(_LIBCPP_NO_VCRUNTIME)
class _LIBCPP_EXCEPTION_ABI exception
{
public:
@@ -110,7 +110,7 @@
virtual ~bad_exception() _NOEXCEPT;
virtual const char* what() const _NOEXCEPT;
};
-#endif // !_LIBCPP_ABI_MICROSOFT
+#endif // !_LIBCPP_ABI_MICROSOFT || _LIBCPP_NO_VCRUNTIME
#if _LIBCPP_STD_VER <= 14 \
|| defined(_LIBCPP_ENABLE_CXX17_REMOVED_UNEXPECTED_FUNCTIONS) \
diff --git a/include/experimental/any b/include/experimental/any
index 022b379..083a290 100644
--- a/include/experimental/any
+++ b/include/experimental/any
@@ -89,7 +89,7 @@
_LIBCPP_BEGIN_NAMESPACE_LFTS
-class _LIBCPP_EXCEPTION_ABI bad_any_cast : public bad_cast
+class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_ANY_CAST bad_any_cast : public bad_cast
{
public:
virtual const char* what() const _NOEXCEPT;
@@ -98,6 +98,7 @@
#if _LIBCPP_STD_VER > 11 // C++ > 11
_LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE
+_LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST
void __throw_bad_any_cast()
{
#ifndef _LIBCPP_NO_EXCEPTIONS
@@ -506,7 +507,7 @@
}
template <class _ValueType>
-_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST
_ValueType any_cast(any const & __v)
{
static_assert(
@@ -522,7 +523,7 @@
}
template <class _ValueType>
-_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST
_ValueType any_cast(any & __v)
{
static_assert(
@@ -537,7 +538,7 @@
}
template <class _ValueType>
-_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST
_ValueType any_cast(any && __v)
{
static_assert(
diff --git a/include/fstream b/include/fstream
index ffd5698..f57908c 100644
--- a/include/fstream
+++ b/include/fstream
@@ -315,7 +315,7 @@
else
this->setp((char_type*)__extbuf_,
(char_type*)__extbuf_ + (__rhs. epptr() - __rhs.pbase()));
- this->pbump(__rhs. pptr() - __rhs.pbase());
+ this->__pbump(__rhs. pptr() - __rhs.pbase());
}
else if (__rhs.eback())
{
@@ -434,7 +434,7 @@
ptrdiff_t __e = this->epptr() - this->pbase();
this->setp((char_type*)__extbuf_min_,
(char_type*)__extbuf_min_ + __e);
- this->pbump(__n);
+ this->__pbump(__n);
}
if (__rhs.eback() == (char_type*)__extbuf_min_)
{
@@ -450,7 +450,7 @@
ptrdiff_t __e = __rhs.epptr() - __rhs.pbase();
__rhs.setp((char_type*)__rhs.__extbuf_min_,
(char_type*)__rhs.__extbuf_min_ + __e);
- __rhs.pbump(__n);
+ __rhs.__pbump(__n);
}
}
@@ -724,7 +724,7 @@
if (__r == codecvt_base::partial)
{
this->setp(const_cast<char_type*>(__e), this->pptr());
- this->pbump(this->epptr() - this->pbase());
+ this->__pbump(this->epptr() - this->pbase());
}
}
else
diff --git a/include/functional b/include/functional
index 83a2e5a..f73c3ca 100644
--- a/include/functional
+++ b/include/functional
@@ -1597,9 +1597,11 @@
return reinterpret_cast<__base*>(p);
}
- template <class _Fp, bool = !is_same<_Fp, function>::value &&
- __invokable<_Fp&, _ArgTypes...>::value>
- struct __callable;
+ template <class _Fp, bool = __lazy_and<
+ integral_constant<bool, !is_same<__uncvref_t<_Fp>, function>::value>,
+ __invokable<_Fp&, _ArgTypes...>
+ >::value>
+ struct __callable;
template <class _Fp>
struct __callable<_Fp, true>
{
@@ -1612,6 +1614,9 @@
{
static const bool value = false;
};
+
+ template <class _Fp>
+ using _EnableIfCallable = typename enable_if<__callable<_Fp>::value>::type;
public:
typedef _Rp result_type;
@@ -1622,9 +1627,7 @@
function(nullptr_t) _NOEXCEPT : __f_(0) {}
function(const function&);
function(function&&) _NOEXCEPT;
- template<class _Fp, class = typename enable_if<
- __callable<_Fp>::value && !is_same<_Fp, function>::value
- >::type>
+ template<class _Fp, class = _EnableIfCallable<_Fp>>
function(_Fp);
#if _LIBCPP_STD_VER <= 14
@@ -1638,21 +1641,15 @@
function(allocator_arg_t, const _Alloc&, const function&);
template<class _Alloc>
function(allocator_arg_t, const _Alloc&, function&&);
- template<class _Fp, class _Alloc, class = typename enable_if<__callable<_Fp>::value>::type>
+ template<class _Fp, class _Alloc, class = _EnableIfCallable<_Fp>>
function(allocator_arg_t, const _Alloc& __a, _Fp __f);
#endif
function& operator=(const function&);
function& operator=(function&&) _NOEXCEPT;
function& operator=(nullptr_t) _NOEXCEPT;
- template<class _Fp>
- typename enable_if
- <
- __callable<typename decay<_Fp>::type>::value &&
- !is_same<typename remove_reference<_Fp>::type, function>::value,
- function&
- >::type
- operator=(_Fp&&);
+ template<class _Fp, class = _EnableIfCallable<_Fp>>
+ function& operator=(_Fp&&);
~function();
@@ -1854,13 +1851,8 @@
}
template<class _Rp, class ..._ArgTypes>
-template <class _Fp>
-typename enable_if
-<
- function<_Rp(_ArgTypes...)>::template __callable<typename decay<_Fp>::type>::value &&
- !is_same<typename remove_reference<_Fp>::type, function<_Rp(_ArgTypes...)>>::value,
- function<_Rp(_ArgTypes...)>&
->::type
+template <class _Fp, class>
+function<_Rp(_ArgTypes...)>&
function<_Rp(_ArgTypes...)>::operator=(_Fp&& __f)
{
function(_VSTD::forward<_Fp>(__f)).swap(*this);
diff --git a/include/iterator b/include/iterator
index d163ab1..9e1da93 100644
--- a/include/iterator
+++ b/include/iterator
@@ -604,21 +604,27 @@
template <class _InputIter>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
-_InputIter
+typename enable_if
+<
+ __is_input_iterator<_InputIter>::value,
+ _InputIter
+>::type
next(_InputIter __x,
- typename iterator_traits<_InputIter>::difference_type __n = 1,
- typename enable_if<__is_input_iterator<_InputIter>::value>::type* = 0)
+ typename iterator_traits<_InputIter>::difference_type __n = 1)
{
_VSTD::advance(__x, __n);
return __x;
}
-template <class _BidiretionalIter>
+template <class _BidirectionalIter>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
-_BidiretionalIter
-prev(_BidiretionalIter __x,
- typename iterator_traits<_BidiretionalIter>::difference_type __n = 1,
- typename enable_if<__is_bidirectional_iterator<_BidiretionalIter>::value>::type* = 0)
+typename enable_if
+<
+ __is_bidirectional_iterator<_BidirectionalIter>::value,
+ _BidirectionalIter
+>::type
+prev(_BidirectionalIter __x,
+ typename iterator_traits<_BidirectionalIter>::difference_type __n = 1)
{
_VSTD::advance(__x, -__n);
return __x;
diff --git a/include/list b/include/list
index 20a66c3..9561a5f 100644
--- a/include/list
+++ b/include/list
@@ -992,6 +992,15 @@
void push_front(const value_type& __x);
void push_back(const value_type& __x);
+#ifndef _LIBCPP_CXX03_LANG
+ template <class _Arg>
+ _LIBCPP_INLINE_VISIBILITY
+ void __emplace_back(_Arg&& __arg) { emplace_back(_VSTD::forward<_Arg>(__arg)); }
+#else
+ _LIBCPP_INLINE_VISIBILITY
+ void __emplace_back(value_type const& __arg) { push_back(__arg); }
+#endif
+
iterator insert(const_iterator __p, const value_type& __x);
iterator insert(const_iterator __p, size_type __n, const value_type& __x);
template <class _InpIter>
@@ -1062,6 +1071,16 @@
bool __invariants() const;
+ typedef __allocator_destructor<__node_allocator> __node_destructor;
+ typedef unique_ptr<__node, __node_destructor> __hold_pointer;
+
+ _LIBCPP_INLINE_VISIBILITY
+ __hold_pointer __allocate_node(__node_allocator& __na) {
+ __node_pointer __p = __node_alloc_traits::allocate(__na, 1);
+ __p->__prev_ = nullptr;
+ return __hold_pointer(__p, __node_destructor(__na, 1));
+ }
+
#if _LIBCPP_DEBUG_LEVEL >= 2
bool __dereferenceable(const const_iterator* __i) const;
@@ -1189,7 +1208,7 @@
__get_db()->__insert_c(this);
#endif
for (; __f != __l; ++__f)
- push_back(*__f);
+ __emplace_back(*__f);
}
template <class _Tp, class _Alloc>
@@ -1202,7 +1221,7 @@
__get_db()->__insert_c(this);
#endif
for (; __f != __l; ++__f)
- push_back(*__f);
+ __emplace_back(*__f);
}
template <class _Tp, class _Alloc>
@@ -1388,9 +1407,7 @@
" referring to this list");
#endif
__node_allocator& __na = base::__node_alloc();
- typedef __allocator_destructor<__node_allocator> _Dp;
- unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
- __hold->__prev_ = 0;
+ __hold_pointer __hold = __allocate_node(__na);
__node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
__link_nodes(__p.__ptr_, __hold->__as_link(), __hold->__as_link());
++base::__sz();
@@ -1417,9 +1434,7 @@
{
size_type __ds = 0;
__node_allocator& __na = base::__node_alloc();
- typedef __allocator_destructor<__node_allocator> _Dp;
- unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
- __hold->__prev_ = 0;
+ __hold_pointer __hold = __allocate_node(__na);
__node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
++__ds;
#if _LIBCPP_DEBUG_LEVEL >= 2
@@ -1485,9 +1500,7 @@
{
size_type __ds = 0;
__node_allocator& __na = base::__node_alloc();
- typedef __allocator_destructor<__node_allocator> _Dp;
- unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
- __hold->__prev_ = 0;
+ __hold_pointer __hold = __allocate_node(__na);
__node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), *__f);
++__ds;
#if _LIBCPP_DEBUG_LEVEL >= 2
@@ -1540,8 +1553,7 @@
list<_Tp, _Alloc>::push_front(const value_type& __x)
{
__node_allocator& __na = base::__node_alloc();
- typedef __allocator_destructor<__node_allocator> _Dp;
- unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
+ __hold_pointer __hold = __allocate_node(__na);
__node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
__link_pointer __nl = __hold->__as_link();
__link_nodes_at_front(__nl, __nl);
@@ -1554,8 +1566,7 @@
list<_Tp, _Alloc>::push_back(const value_type& __x)
{
__node_allocator& __na = base::__node_alloc();
- typedef __allocator_destructor<__node_allocator> _Dp;
- unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
+ __hold_pointer __hold = __allocate_node(__na);
__node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
__link_nodes_at_back(__hold.get()->__as_link(), __hold.get()->__as_link());
++base::__sz();
@@ -1569,8 +1580,7 @@
list<_Tp, _Alloc>::push_front(value_type&& __x)
{
__node_allocator& __na = base::__node_alloc();
- typedef __allocator_destructor<__node_allocator> _Dp;
- unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
+ __hold_pointer __hold = __allocate_node(__na);
__node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::move(__x));
__link_nodes_at_front(__hold.get()->__as_link(), __hold.get()->__as_link());
++base::__sz();
@@ -1582,8 +1592,7 @@
list<_Tp, _Alloc>::push_back(value_type&& __x)
{
__node_allocator& __na = base::__node_alloc();
- typedef __allocator_destructor<__node_allocator> _Dp;
- unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
+ __hold_pointer __hold = __allocate_node(__na);
__node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::move(__x));
__link_nodes_at_back(__hold.get()->__as_link(), __hold.get()->__as_link());
++base::__sz();
@@ -1600,8 +1609,7 @@
list<_Tp, _Alloc>::emplace_front(_Args&&... __args)
{
__node_allocator& __na = base::__node_alloc();
- typedef __allocator_destructor<__node_allocator> _Dp;
- unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
+ __hold_pointer __hold = __allocate_node(__na);
__node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::forward<_Args>(__args)...);
__link_nodes_at_front(__hold.get()->__as_link(), __hold.get()->__as_link());
++base::__sz();
@@ -1622,8 +1630,7 @@
list<_Tp, _Alloc>::emplace_back(_Args&&... __args)
{
__node_allocator& __na = base::__node_alloc();
- typedef __allocator_destructor<__node_allocator> _Dp;
- unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
+ __hold_pointer __hold = __allocate_node(__na);
__node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::forward<_Args>(__args)...);
__link_pointer __nl = __hold->__as_link();
__link_nodes_at_back(__nl, __nl);
@@ -1646,9 +1653,7 @@
" referring to this list");
#endif
__node_allocator& __na = base::__node_alloc();
- typedef __allocator_destructor<__node_allocator> _Dp;
- unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
- __hold->__prev_ = 0;
+ __hold_pointer __hold = __allocate_node(__na);
__node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::forward<_Args>(__args)...);
__link_pointer __nl = __hold.get()->__as_link();
__link_nodes(__p.__ptr_, __nl, __nl);
@@ -1671,9 +1676,7 @@
" referring to this list");
#endif
__node_allocator& __na = base::__node_alloc();
- typedef __allocator_destructor<__node_allocator> _Dp;
- unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
- __hold->__prev_ = 0;
+ __hold_pointer __hold = __allocate_node(__na);
__node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::move(__x));
__link_pointer __nl = __hold->__as_link();
__link_nodes(__p.__ptr_, __nl, __nl);
@@ -1846,9 +1849,7 @@
__n -= base::__sz();
size_type __ds = 0;
__node_allocator& __na = base::__node_alloc();
- typedef __allocator_destructor<__node_allocator> _Dp;
- unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
- __hold->__prev_ = 0;
+ __hold_pointer __hold = __allocate_node(__na);
__node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_));
++__ds;
#if _LIBCPP_DEBUG_LEVEL >= 2
@@ -1905,9 +1906,7 @@
__n -= base::__sz();
size_type __ds = 0;
__node_allocator& __na = base::__node_alloc();
- typedef __allocator_destructor<__node_allocator> _Dp;
- unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
- __hold->__prev_ = 0;
+ __hold_pointer __hold = __allocate_node(__na);
__node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
++__ds;
__link_pointer __nl = __hold.release()->__as_link();
diff --git a/include/locale b/include/locale
index d30d950..a86645d 100644
--- a/include/locale
+++ b/include/locale
@@ -4110,7 +4110,7 @@
if (__r == codecvt_base::partial)
{
this->setp(const_cast<char_type *>(__e), this->pptr());
- this->pbump(this->epptr() - this->pbase());
+ this->__pbump(this->epptr() - this->pbase());
}
}
else
diff --git a/include/memory b/include/memory
index 22706d0..351529a 100644
--- a/include/memory
+++ b/include/memory
@@ -724,7 +724,7 @@
struct __has_element_type : false_type {};
template <class _Tp>
-struct __has_element_type<_Tp,
+struct __has_element_type<_Tp,
typename __void_t<typename _Tp::element_type>::type> : true_type {};
template <class _Ptr, bool = __has_element_type<_Ptr>::value>
@@ -808,7 +808,7 @@
struct __has_difference_type : false_type {};
template <class _Tp>
-struct __has_difference_type<_Tp,
+struct __has_difference_type<_Tp,
typename __void_t<typename _Tp::difference_type>::type> : true_type {};
template <class _Ptr, bool = __has_difference_type<_Ptr>::value>
@@ -994,7 +994,7 @@
struct __has_pointer_type : false_type {};
template <class _Tp>
-struct __has_pointer_type<_Tp,
+struct __has_pointer_type<_Tp,
typename __void_t<typename _Tp::pointer>::type> : true_type {};
namespace __pointer_type_imp
@@ -1024,7 +1024,7 @@
struct __has_const_pointer : false_type {};
template <class _Tp>
-struct __has_const_pointer<_Tp,
+struct __has_const_pointer<_Tp,
typename __void_t<typename _Tp::const_pointer>::type> : true_type {};
template <class _Tp, class _Ptr, class _Alloc, bool = __has_const_pointer<_Alloc>::value>
@@ -1047,7 +1047,7 @@
struct __has_void_pointer : false_type {};
template <class _Tp>
-struct __has_void_pointer<_Tp,
+struct __has_void_pointer<_Tp,
typename __void_t<typename _Tp::void_pointer>::type> : true_type {};
template <class _Ptr, class _Alloc, bool = __has_void_pointer<_Alloc>::value>
@@ -1070,7 +1070,7 @@
struct __has_const_void_pointer : false_type {};
template <class _Tp>
-struct __has_const_void_pointer<_Tp,
+struct __has_const_void_pointer<_Tp,
typename __void_t<typename _Tp::const_void_pointer>::type> : true_type {};
template <class _Ptr, class _Alloc, bool = __has_const_void_pointer<_Alloc>::value>
@@ -1148,7 +1148,7 @@
struct __has_propagate_on_container_move_assignment : false_type {};
template <class _Tp>
-struct __has_propagate_on_container_move_assignment<_Tp,
+struct __has_propagate_on_container_move_assignment<_Tp,
typename __void_t<typename _Tp::propagate_on_container_move_assignment>::type>
: true_type {};
@@ -1168,7 +1168,7 @@
struct __has_propagate_on_container_swap : false_type {};
template <class _Tp>
-struct __has_propagate_on_container_swap<_Tp,
+struct __has_propagate_on_container_swap<_Tp,
typename __void_t<typename _Tp::propagate_on_container_swap>::type>
: true_type {};
@@ -1188,7 +1188,7 @@
struct __has_is_always_equal : false_type {};
template <class _Tp>
-struct __has_is_always_equal<_Tp,
+struct __has_is_always_equal<_Tp,
typename __void_t<typename _Tp::is_always_equal>::type>
: true_type {};
@@ -1302,7 +1302,7 @@
template <class _Alloc, class _SizeType, class _ConstVoidPtr>
auto
__has_allocate_hint_test(_Alloc&& __a, _SizeType&& __sz, _ConstVoidPtr&& __p)
- -> decltype(__a.allocate(__sz, __p), true_type());
+ -> decltype((void)__a.allocate(__sz, __p), true_type());
template <class _Alloc, class _SizeType, class _ConstVoidPtr>
auto
@@ -1313,7 +1313,7 @@
struct __has_allocate_hint
: integral_constant<bool,
is_same<
- decltype(__has_allocate_hint_test(declval<_Alloc>(),
+ decltype(_VSTD::__has_allocate_hint_test(declval<_Alloc>(),
declval<_SizeType>(),
declval<_ConstVoidPtr>())),
true_type>::value>
@@ -1346,7 +1346,7 @@
struct __has_construct
: integral_constant<bool,
is_same<
- decltype(__has_construct_test(declval<_Alloc>(),
+ decltype(_VSTD::__has_construct_test(declval<_Alloc>(),
declval<_Pointer>(),
declval<_Args>()...)),
true_type>::value>
@@ -1367,7 +1367,7 @@
struct __has_destroy
: integral_constant<bool,
is_same<
- decltype(__has_destroy_test(declval<_Alloc>(),
+ decltype(_VSTD::__has_destroy_test(declval<_Alloc>(),
declval<_Pointer>())),
true_type>::value>
{
@@ -1387,7 +1387,7 @@
struct __has_max_size
: integral_constant<bool,
is_same<
- decltype(__has_max_size_test(declval<_Alloc&>())),
+ decltype(_VSTD::__has_max_size_test(declval<_Alloc&>())),
true_type>::value>
{
};
@@ -1406,7 +1406,7 @@
struct __has_select_on_container_copy_construction
: integral_constant<bool,
is_same<
- decltype(__has_select_on_container_copy_construction_test(declval<_Alloc&>())),
+ decltype(_VSTD::__has_select_on_container_copy_construction_test(declval<_Alloc&>())),
true_type>::value>
{
};
@@ -1941,7 +1941,7 @@
_LIBCPP_INLINE_VISIBILITY raw_storage_iterator operator++(int)
{raw_storage_iterator __t(*this); ++__x_; return __t;}
#if _LIBCPP_STD_VER >= 14
- _LIBCPP_INLINE_VISIBILITY _OutputIterator base() const { return __x_; }
+ _LIBCPP_INLINE_VISIBILITY _OutputIterator base() const { return __x_; }
#endif
};
@@ -3850,7 +3850,7 @@
_LIBCPP_INLINE_VISIBILITY
_Dp* __get_deleter() const _NOEXCEPT
{return static_cast<_Dp*>(__cntrl_
- ? const_cast<void *>(__cntrl_->__get_deleter(typeid(_Dp)))
+ ? const_cast<void *>(__cntrl_->__get_deleter(typeid(_Dp)))
: nullptr);}
#endif // _LIBCPP_NO_RTTI
@@ -4477,7 +4477,7 @@
typename enable_if
<
!is_array<_Yp>::value &&
- is_convertible<typename unique_ptr<_Yp, _Dp>::pointer,
+ is_convertible<typename unique_ptr<_Yp, _Dp>::pointer,
typename shared_ptr<_Tp>::element_type*>::value,
shared_ptr<_Tp>&
>::type
@@ -4512,7 +4512,7 @@
typename enable_if
<
!is_array<_Yp>::value &&
- is_convertible<typename unique_ptr<_Yp, _Dp>::pointer,
+ is_convertible<typename unique_ptr<_Yp, _Dp>::pointer,
typename shared_ptr<_Tp>::element_type*>::value,
shared_ptr<_Tp>&
>::type
@@ -5311,7 +5311,7 @@
__m.unlock();
return __q;
}
-
+
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
@@ -5352,7 +5352,7 @@
__m.unlock();
return __r;
}
-
+
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
@@ -5484,7 +5484,7 @@
_NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value)
#endif
{
- __swap_allocator(__a1, __a2,
+ __swap_allocator(__a1, __a2,
integral_constant<bool, _VSTD::allocator_traits<_Alloc>::propagate_on_container_swap::value>());
}
@@ -5506,7 +5506,7 @@
void __swap_allocator(_Alloc &, _Alloc &, false_type) _NOEXCEPT {}
template <typename _Alloc, typename _Traits=allocator_traits<_Alloc> >
-struct __noexcept_move_assign_container : public integral_constant<bool,
+struct __noexcept_move_assign_container : public integral_constant<bool,
_Traits::propagate_on_container_move_assignment::value
#if _LIBCPP_STD_VER > 14
|| _Traits::is_always_equal::value
@@ -5520,17 +5520,17 @@
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
diff --git a/include/mutex b/include/mutex
index 1557ed8..fbcc098 100644
--- a/include/mutex
+++ b/include/mutex
@@ -116,7 +116,7 @@
using mutex_type = Mutex; // If MutexTypes... consists of the single type Mutex
explicit scoped_lock(MutexTypes&... m);
- scoped_lock(MutexTypes&... m, adopt_lock_t);
+ scoped_lock(adopt_lock_t, MutexTypes&... m);
~scoped_lock();
scoped_lock(scoped_lock const&) = delete;
scoped_lock& operator=(scoped_lock const&) = delete;
@@ -500,7 +500,7 @@
~scoped_lock() _LIBCPP_THREAD_SAFETY_ANNOTATION(release_capability()) {__m_.unlock();}
_LIBCPP_INLINE_VISIBILITY
- explicit scoped_lock(mutex_type& __m, adopt_lock_t) _LIBCPP_THREAD_SAFETY_ANNOTATION(requires_capability(__m))
+ explicit scoped_lock(adopt_lock_t, mutex_type& __m) _LIBCPP_THREAD_SAFETY_ANNOTATION(requires_capability(__m))
: __m_(__m) {}
scoped_lock(scoped_lock const&) = delete;
@@ -522,7 +522,7 @@
}
_LIBCPP_INLINE_VISIBILITY
- scoped_lock(_MArgs&... __margs, adopt_lock_t)
+ scoped_lock(adopt_lock_t, _MArgs&... __margs)
: __t_(__margs...)
{
}
diff --git a/include/new b/include/new
index 34df2ef..06cf4a3 100644
--- a/include/new
+++ b/include/new
@@ -92,7 +92,7 @@
#include <cstdlib>
#endif
-#if defined(_LIBCPP_ABI_MICROSOFT)
+#if defined(_LIBCPP_ABI_MICROSOFT) && !defined(_LIBCPP_NO_VCRUNTIME)
#include <new.h>
#endif
@@ -114,7 +114,7 @@
namespace std // purposefully not using versioning namespace
{
-#if !defined(_LIBCPP_ABI_MICROSOFT)
+#if !defined(_LIBCPP_ABI_MICROSOFT) || defined(_LIBCPP_NO_VCRUNTIME)
struct _LIBCPP_TYPE_VIS nothrow_t {};
extern _LIBCPP_FUNC_VIS const nothrow_t nothrow;
@@ -140,7 +140,7 @@
_LIBCPP_FUNC_VIS new_handler set_new_handler(new_handler) _NOEXCEPT;
_LIBCPP_FUNC_VIS new_handler get_new_handler() _NOEXCEPT;
-#endif // !_LIBCPP_ABI_MICROSOFT
+#endif // !_LIBCPP_ABI_MICROSOFT || _LIBCPP_NO_VCRUNTIME
_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void __throw_bad_alloc(); // not in C++ spec
@@ -174,7 +174,7 @@
#define _THROW_BAD_ALLOC
#endif
-#if !defined(_LIBCPP_ABI_MICROSOFT)
+#if !defined(_LIBCPP_ABI_MICROSOFT) || defined(_LIBCPP_NO_VCRUNTIME)
_LIBCPP_OVERRIDABLE_FUNC_VIS void* operator new(std::size_t __sz) _THROW_BAD_ALLOC;
_LIBCPP_OVERRIDABLE_FUNC_VIS void* operator new(std::size_t __sz, const std::nothrow_t&) _NOEXCEPT _NOALIAS;
@@ -215,7 +215,7 @@
inline _LIBCPP_INLINE_VISIBILITY void operator delete (void*, void*) _NOEXCEPT {}
inline _LIBCPP_INLINE_VISIBILITY void operator delete[](void*, void*) _NOEXCEPT {}
-#endif // !_LIBCPP_ABI_MICROSOFT
+#endif // !_LIBCPP_ABI_MICROSOFT || _LIBCPP_NO_VCRUNTIME
_LIBCPP_BEGIN_NAMESPACE_STD
diff --git a/include/numeric b/include/numeric
index 39e8193..1b7d97c 100644
--- a/include/numeric
+++ b/include/numeric
@@ -81,6 +81,20 @@
exclusive_scan(InputIterator first, InputIterator last,
OutputIterator result, T init, BinaryOperation binary_op); // C++17
+template<class InputIterator, class OutputIterator>
+ OutputIterator
+ inclusive_scan(InputIterator first, InputIterator last, OutputIterator result); // C++17
+
+template<class InputIterator, class OutputIterator, class BinaryOperation>
+ OutputIterator
+ inclusive_scan(InputIterator first, InputIterator last,
+ OutputIterator result, BinaryOperation binary_op); // C++17
+
+template<class InputIterator, class OutputIterator, class BinaryOperation, class T>
+ OutputIterator
+ inclusive_scan(InputIterator first, InputIterator last,
+ OutputIterator result, BinaryOperation binary_op, T init); // C++17
+
template<class InputIterator, class OutputIterator, class T,
class BinaryOperation, class UnaryOperation>
OutputIterator
@@ -88,6 +102,21 @@
OutputIterator result, T init,
BinaryOperation binary_op, UnaryOperation unary_op); // C++17
+template<class InputIterator, class OutputIterator,
+ class BinaryOperation, class UnaryOperation>
+ OutputIterator
+ transform_inclusive_scan(InputIterator first, InputIterator last,
+ OutputIterator result,
+ BinaryOperation binary_op, UnaryOperation unary_op); // C++17
+
+template<class InputIterator, class OutputIterator,
+ class BinaryOperation, class UnaryOperation, class T>
+ OutputIterator
+ transform_inclusive_scan(InputIterator first, InputIterator last,
+ OutputIterator result,
+ BinaryOperation binary_op, UnaryOperation unary_op,
+ T init); // C++17
+
template <class InputIterator, class OutputIterator>
OutputIterator
adjacent_difference(InputIterator first, InputIterator last, OutputIterator result);
@@ -295,6 +324,38 @@
return _VSTD::exclusive_scan(__first, __last, __result, __init, _VSTD::plus<>());
}
+template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp>
+_OutputIterator inclusive_scan(_InputIterator __first, _InputIterator __last,
+ _OutputIterator __result, _BinaryOp __b, _Tp __init)
+{
+ for (; __first != __last; ++__first, (void) ++__result) {
+ __init = __b(__init, *__first);
+ *__result = __init;
+ }
+ return __result;
+}
+
+template <class _InputIterator, class _OutputIterator, class _BinaryOp>
+_OutputIterator inclusive_scan(_InputIterator __first, _InputIterator __last,
+ _OutputIterator __result, _BinaryOp __b)
+{
+ if (__first != __last) {
+ typename std::iterator_traits<_InputIterator>::value_type __init = *__first;
+ *__result++ = __init;
+ if (++__first != __last)
+ return _VSTD::inclusive_scan(__first, __last, __result, __b, __init);
+ }
+
+ return __result;
+}
+
+template <class _InputIterator, class _OutputIterator>
+_OutputIterator inclusive_scan(_InputIterator __first, _InputIterator __last,
+ _OutputIterator __result)
+{
+ return _VSTD::inclusive_scan(__first, __last, __result, std::plus<>());
+}
+
template <class _InputIterator, class _OutputIterator, class _Tp,
class _BinaryOp, class _UnaryOp>
inline _LIBCPP_INLINE_VISIBILITY
@@ -316,6 +377,32 @@
}
return __result;
}
+
+template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp, class _UnaryOp>
+_OutputIterator transform_inclusive_scan(_InputIterator __first, _InputIterator __last,
+ _OutputIterator __result, _BinaryOp __b, _UnaryOp __u, _Tp __init)
+{
+ for (; __first != __last; ++__first, (void) ++__result) {
+ __init = __b(__init, __u(*__first));
+ *__result = __init;
+ }
+
+ return __result;
+}
+
+template <class _InputIterator, class _OutputIterator, class _BinaryOp, class _UnaryOp>
+_OutputIterator transform_inclusive_scan(_InputIterator __first, _InputIterator __last,
+ _OutputIterator __result, _BinaryOp __b, _UnaryOp __u)
+{
+ if (__first != __last) {
+ typename std::iterator_traits<_InputIterator>::value_type __init = __u(*__first);
+ *__result++ = __init;
+ if (++__first != __last)
+ return _VSTD::transform_inclusive_scan(__first, __last, __result, __b, __u, __init);
+ }
+
+ return __result;
+}
#endif
template <class _InputIterator, class _OutputIterator>
diff --git a/include/optional b/include/optional
index c0fd0e7..1fb953b 100644
--- a/include/optional
+++ b/include/optional
@@ -439,46 +439,122 @@
}
};
-template <class _Tp, bool = is_trivially_copyable<_Tp>::value>
-struct __optional_storage;
-
-template <class _Tp>
-struct __optional_storage<_Tp, true> : __optional_storage_base<_Tp>
+template <class _Tp, bool = is_trivially_copy_constructible<_Tp>::value>
+struct __optional_copy_base : __optional_storage_base<_Tp>
{
using __optional_storage_base<_Tp>::__optional_storage_base;
};
template <class _Tp>
-struct __optional_storage<_Tp, false> : __optional_storage_base<_Tp>
+struct __optional_copy_base<_Tp, false> : __optional_storage_base<_Tp>
{
- using value_type = _Tp;
using __optional_storage_base<_Tp>::__optional_storage_base;
_LIBCPP_INLINE_VISIBILITY
- __optional_storage() = default;
+ __optional_copy_base() = default;
_LIBCPP_INLINE_VISIBILITY
- __optional_storage(const __optional_storage& __opt)
+ __optional_copy_base(const __optional_copy_base& __opt)
{
this->__construct_from(__opt);
}
_LIBCPP_INLINE_VISIBILITY
- __optional_storage(__optional_storage&& __opt)
+ __optional_copy_base(__optional_copy_base&&) = default;
+ _LIBCPP_INLINE_VISIBILITY
+ __optional_copy_base& operator=(const __optional_copy_base&) = default;
+ _LIBCPP_INLINE_VISIBILITY
+ __optional_copy_base& operator=(__optional_copy_base&&) = default;
+};
+
+template <class _Tp, bool = is_trivially_move_constructible<_Tp>::value>
+struct __optional_move_base : __optional_copy_base<_Tp>
+{
+ using __optional_copy_base<_Tp>::__optional_copy_base;
+};
+
+template <class _Tp>
+struct __optional_move_base<_Tp, false> : __optional_copy_base<_Tp>
+{
+ using value_type = _Tp;
+ using __optional_copy_base<_Tp>::__optional_copy_base;
+
+ _LIBCPP_INLINE_VISIBILITY
+ __optional_move_base() = default;
+ _LIBCPP_INLINE_VISIBILITY
+ __optional_move_base(const __optional_move_base&) = default;
+
+ _LIBCPP_INLINE_VISIBILITY
+ __optional_move_base(__optional_move_base&& __opt)
noexcept(is_nothrow_move_constructible_v<value_type>)
{
this->__construct_from(_VSTD::move(__opt));
}
_LIBCPP_INLINE_VISIBILITY
- __optional_storage& operator=(const __optional_storage& __opt)
+ __optional_move_base& operator=(const __optional_move_base&) = default;
+ _LIBCPP_INLINE_VISIBILITY
+ __optional_move_base& operator=(__optional_move_base&&) = default;
+};
+
+template <class _Tp, bool =
+ is_trivially_destructible<_Tp>::value &&
+ is_trivially_copy_constructible<_Tp>::value &&
+ is_trivially_copy_assignable<_Tp>::value>
+struct __optional_copy_assign_base : __optional_move_base<_Tp>
+{
+ using __optional_move_base<_Tp>::__optional_move_base;
+};
+
+template <class _Tp>
+struct __optional_copy_assign_base<_Tp, false> : __optional_move_base<_Tp>
+{
+ using __optional_move_base<_Tp>::__optional_move_base;
+
+ _LIBCPP_INLINE_VISIBILITY
+ __optional_copy_assign_base() = default;
+ _LIBCPP_INLINE_VISIBILITY
+ __optional_copy_assign_base(const __optional_copy_assign_base&) = default;
+ _LIBCPP_INLINE_VISIBILITY
+ __optional_copy_assign_base(__optional_copy_assign_base&&) = default;
+
+ _LIBCPP_INLINE_VISIBILITY
+ __optional_copy_assign_base& operator=(const __optional_copy_assign_base& __opt)
{
this->__assign_from(__opt);
return *this;
}
_LIBCPP_INLINE_VISIBILITY
- __optional_storage& operator=(__optional_storage&& __opt)
+ __optional_copy_assign_base& operator=(__optional_copy_assign_base&&) = default;
+};
+
+template <class _Tp, bool =
+ is_trivially_destructible<_Tp>::value &&
+ is_trivially_move_constructible<_Tp>::value &&
+ is_trivially_move_assignable<_Tp>::value>
+struct __optional_move_assign_base : __optional_copy_assign_base<_Tp>
+{
+ using __optional_copy_assign_base<_Tp>::__optional_copy_assign_base;
+};
+
+template <class _Tp>
+struct __optional_move_assign_base<_Tp, false> : __optional_copy_assign_base<_Tp>
+{
+ using value_type = _Tp;
+ using __optional_copy_assign_base<_Tp>::__optional_copy_assign_base;
+
+ _LIBCPP_INLINE_VISIBILITY
+ __optional_move_assign_base() = default;
+ _LIBCPP_INLINE_VISIBILITY
+ __optional_move_assign_base(const __optional_move_assign_base& __opt) = default;
+ _LIBCPP_INLINE_VISIBILITY
+ __optional_move_assign_base(__optional_move_assign_base&&) = default;
+ _LIBCPP_INLINE_VISIBILITY
+ __optional_move_assign_base& operator=(const __optional_move_assign_base&) = default;
+
+ _LIBCPP_INLINE_VISIBILITY
+ __optional_move_assign_base& operator=(__optional_move_assign_base&& __opt)
noexcept(is_nothrow_move_assignable_v<value_type> &&
is_nothrow_move_constructible_v<value_type>)
{
@@ -501,11 +577,11 @@
template <class _Tp>
class optional
- : private __optional_storage<_Tp>
+ : private __optional_move_assign_base<_Tp>
, private __optional_sfinae_ctor_base_t<_Tp>
, private __optional_sfinae_assign_base_t<_Tp>
{
- using __base = __optional_storage<_Tp>;
+ using __base = __optional_move_assign_base<_Tp>;
public:
using value_type = _Tp;
diff --git a/include/random b/include/random
index ba8a088..9073a52 100644
--- a/include/random
+++ b/include/random
@@ -2308,6 +2308,7 @@
void
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b,
__t, __c, __l, __f>::seed(result_type __sd)
+ _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
{ // __w >= 2
__x_[0] = __sd & _Max;
for (size_t __i = 1; __i < __n; ++__i)
diff --git a/include/regex b/include/regex
index 443c2e3..7981352 100644
--- a/include/regex
+++ b/include/regex
@@ -773,6 +773,8 @@
#include <__undef_macros>
+#define _LIBCPP_REGEX_COMPLEXITY_FACTOR 4096
+
_LIBCPP_BEGIN_NAMESPACE_STD
namespace regex_constants
@@ -2407,17 +2409,28 @@
goto __exit;
}
}
- if (!__neg_chars_.empty())
+ // set of "__found" chars =
+ // union(complement(union(__neg_chars_, __neg_mask_)),
+ // other cases...)
+ //
+ // __neg_chars_ and __neg_mask_'d better be handled together, as there
+ // are no short circuit opportunities.
+ //
+ // In addition, when __neg_mask_/__neg_chars_ is empty, they should be
+ // treated as all ones/all chars.
{
- for (size_t __i = 0; __i < __neg_chars_.size(); ++__i)
- {
- if (__ch == __neg_chars_[__i])
- goto __is_neg_char;
- }
+ const bool __in_neg_mask = (__neg_mask_ == 0) ||
+ __traits_.isctype(__ch, __neg_mask_);
+ const bool __in_neg_chars =
+ __neg_chars_.empty() ||
+ std::find(__neg_chars_.begin(), __neg_chars_.end(), __ch) !=
+ __neg_chars_.end();
+ if (!(__in_neg_mask || __in_neg_chars))
+ {
__found = true;
goto __exit;
+ }
}
-__is_neg_char:
if (!__ranges_.empty())
{
string_type __s2 = __collate_ ?
@@ -2449,11 +2462,6 @@
__found = true;
goto __exit;
}
- if (__neg_mask_ && !__traits_.isctype(__ch, __neg_mask_))
- {
- __found = true;
- goto __exit;
- }
}
else
__found = __negate_; // force reject
@@ -4056,6 +4064,8 @@
__first != __last && ( __val = __traits_.value(*__first, 10)) != -1;
++__first)
{
+ if (__c >= std::numeric_limits<int>::max() / 10)
+ __throw_regex_error<regex_constants::error_badbrace>();
__c *= 10;
__c += __val;
}
@@ -4317,8 +4327,12 @@
unsigned __v = *__first - '0';
for (++__first;
__first != __last && '0' <= *__first && *__first <= '9'; ++__first)
+ {
+ if (__v >= std::numeric_limits<unsigned>::max() / 10)
+ __throw_regex_error<regex_constants::error_backref>();
__v = 10 * __v + *__first - '0';
- if (__v > mark_count())
+ }
+ if (__v == 0 || __v > mark_count())
__throw_regex_error<regex_constants::error_backref>();
__push_back_ref(__v);
}
@@ -5445,15 +5459,17 @@
if ('0' <= __fmt_first[1] && __fmt_first[1] <= '9')
{
++__fmt_first;
- size_t __i = *__fmt_first - '0';
+ size_t __idx = *__fmt_first - '0';
if (__fmt_first + 1 != __fmt_last &&
'0' <= __fmt_first[1] && __fmt_first[1] <= '9')
{
++__fmt_first;
- __i = 10 * __i + *__fmt_first - '0';
+ if (__idx >= std::numeric_limits<size_t>::max() / 10)
+ __throw_regex_error<regex_constants::error_escape>();
+ __idx = 10 * __idx + *__fmt_first - '0';
}
- __output = _VSTD::copy((*this)[__i].first,
- (*this)[__i].second, __output);
+ __output = _VSTD::copy((*this)[__idx].first,
+ (*this)[__idx].second, __output);
}
else
{
@@ -5552,8 +5568,14 @@
__states.back().__node_ = __st;
__states.back().__flags_ = __flags;
__states.back().__at_first_ = __at_first;
+ int __counter = 0;
+ int __length = __last - __first;
do
{
+ ++__counter;
+ if (__counter % _LIBCPP_REGEX_COMPLEXITY_FACTOR == 0 &&
+ __counter / _LIBCPP_REGEX_COMPLEXITY_FACTOR >= __length)
+ __throw_regex_error<regex_constants::error_complexity>();
__state& __s = __states.back();
if (__s.__node_)
__s.__node_->__exec(__s);
@@ -5627,8 +5649,14 @@
__states.back().__flags_ = __flags;
__states.back().__at_first_ = __at_first;
bool __matched = false;
+ int __counter = 0;
+ int __length = __last - __first;
do
{
+ ++__counter;
+ if (__counter % _LIBCPP_REGEX_COMPLEXITY_FACTOR == 0 &&
+ __counter / _LIBCPP_REGEX_COMPLEXITY_FACTOR >= __length)
+ __throw_regex_error<regex_constants::error_complexity>();
__state& __s = __states.back();
if (__s.__node_)
__s.__node_->__exec(__s);
@@ -5724,8 +5752,14 @@
__states.back().__at_first_ = __at_first;
const _CharT* __current = __first;
bool __matched = false;
+ int __counter = 0;
+ int __length = __last - __first;
do
{
+ ++__counter;
+ if (__counter % _LIBCPP_REGEX_COMPLEXITY_FACTOR == 0 &&
+ __counter / _LIBCPP_REGEX_COMPLEXITY_FACTOR >= __length)
+ __throw_regex_error<regex_constants::error_complexity>();
__state& __s = __states.back();
if (__s.__node_)
__s.__node_->__exec(__s);
@@ -6142,7 +6176,7 @@
{
__flags_ |= regex_constants::__no_update_pos;
_BidirectionalIterator __start = __match_[0].second;
- if (__match_.empty())
+ if (__match_[0].first == __match_[0].second)
{
if (__start == __end_)
{
diff --git a/include/sstream b/include/sstream
index b9903f9..31cb37a 100644
--- a/include/sstream
+++ b/include/sstream
@@ -249,7 +249,8 @@
template <class _CharT, class _Traits, class _Allocator>
basic_stringbuf<_CharT, _Traits, _Allocator>::basic_stringbuf(const string_type& __s,
ios_base::openmode __wch)
- : __hm_(0),
+ : __str_(__s.get_allocator()),
+ __hm_(0),
__mode_(__wch)
{
str(__s);
@@ -288,7 +289,7 @@
if (__bout != -1)
{
this->setp(__p + __bout, __p + __eout);
- this->pbump(__nout);
+ this->__pbump(__nout);
}
__hm_ = __hm == -1 ? nullptr : __p + __hm;
__p = const_cast<char_type*>(__rhs.__str_.data());
@@ -331,7 +332,7 @@
if (__bout != -1)
{
this->setp(__p + __bout, __p + __eout);
- this->pbump(__nout);
+ this->__pbump(__nout);
}
else
this->setp(nullptr, nullptr);
@@ -402,7 +403,7 @@
if (__rbout != -1)
{
this->setp(__p + __rbout, __p + __reout);
- this->pbump(__rnout);
+ this->__pbump(__rnout);
}
else
this->setp(nullptr, nullptr);
@@ -415,7 +416,7 @@
if (__lbout != -1)
{
__rhs.setp(__p + __lbout, __p + __leout);
- __rhs.pbump(__lnout);
+ __rhs.__pbump(__lnout);
}
else
__rhs.setp(nullptr, nullptr);
@@ -470,7 +471,15 @@
this->setp(const_cast<char_type*>(__str_.data()),
const_cast<char_type*>(__str_.data()) + __str_.size());
if (__mode_ & (ios_base::app | ios_base::ate))
- this->pbump(__sz);
+ {
+ while (__sz > INT_MAX)
+ {
+ this->pbump(INT_MAX);
+ __sz -= INT_MAX;
+ }
+ if (__sz > 0)
+ this->pbump(__sz);
+ }
}
}
@@ -535,7 +544,7 @@
__str_.resize(__str_.capacity());
char_type* __p = const_cast<char_type*>(__str_.data());
this->setp(__p, __p + __str_.size());
- this->pbump(__nout);
+ this->__pbump(__nout);
__hm_ = this->pbase() + __hm;
#ifndef _LIBCPP_NO_EXCEPTIONS
}
diff --git a/include/streambuf b/include/streambuf
index a10ce1b..ea64f57 100644
--- a/include/streambuf
+++ b/include/streambuf
@@ -255,6 +255,9 @@
inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
void pbump(int __n) { __nout_ += __n; }
+ _LIBCPP_ALWAYS_INLINE
+ void __pbump(streamsize __n) { __nout_ += __n; }
+
inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
void setp(char_type* __pbeg, char_type* __pend) {
__bout_ = __nout_ = __pbeg;
@@ -404,7 +407,8 @@
{
if (__ninp_ < __einp_)
{
- const streamsize __len = _VSTD::min(__einp_ - __ninp_, __n - __i);
+ const streamsize __len = _VSTD::min(static_cast<streamsize>(INT_MAX),
+ _VSTD::min(__einp_ - __ninp_, __n - __i));
traits_type::copy(__s, __ninp_, __len);
__s += __len;
__i += __len;
diff --git a/include/string b/include/string
index accf1ce..acd2876 100644
--- a/include/string
+++ b/include/string
@@ -259,7 +259,7 @@
size_type find(value_type c, size_type pos = 0) const noexcept;
size_type rfind(const basic_string& str, size_type pos = npos) const noexcept;
- size_type ffind(basic_string_view<charT, traits> sv, size_type pos = 0) const noexcept;
+ size_type rfind(basic_string_view<charT, traits> sv, size_type pos = npos) const noexcept;
size_type rfind(const value_type* s, size_type pos, size_type n) const noexcept;
size_type rfind(const value_type* s, size_type pos = npos) const noexcept;
size_type rfind(value_type c, size_type pos = npos) const noexcept;
@@ -271,7 +271,7 @@
size_type find_first_of(value_type c, size_type pos = 0) const noexcept;
size_type find_last_of(const basic_string& str, size_type pos = npos) const noexcept;
- size_type find_last_of(basic_string_view<charT, traits> sv, size_type pos = 0) const noexcept;
+ size_type find_last_of(basic_string_view<charT, traits> sv, size_type pos = npos) const noexcept;
size_type find_last_of(const value_type* s, size_type pos, size_type n) const noexcept;
size_type find_last_of(const value_type* s, size_type pos = npos) const noexcept;
size_type find_last_of(value_type c, size_type pos = npos) const noexcept;
@@ -283,7 +283,7 @@
size_type find_first_not_of(value_type c, size_type pos = 0) const noexcept;
size_type find_last_not_of(const basic_string& str, size_type pos = npos) const noexcept;
- size_type find_last_not_of(basic_string_view<charT, traits> sv, size_type pos = 0) const noexcept;
+ size_type find_last_not_of(basic_string_view<charT, traits> sv, size_type pos = npos) const noexcept;
size_type find_last_not_of(const value_type* s, size_type pos, size_type n) const noexcept;
size_type find_last_not_of(const value_type* s, size_type pos = npos) const noexcept;
size_type find_last_not_of(value_type c, size_type pos = npos) const noexcept;
@@ -556,6 +556,8 @@
basic_string<_CharT, _Traits, _Allocator>
operator+(const basic_string<_CharT, _Traits, _Allocator>& __x, _CharT __y);
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS string operator+<char, char_traits<char>, allocator<char> >(char const*, string const&))
+
template <bool>
class _LIBCPP_TEMPLATE_VIS __basic_string_common
{
@@ -578,14 +580,7 @@
_VSTD::__throw_out_of_range("basic_string");
}
-#ifdef _LIBCPP_MSVC
-#pragma warning( push )
-#pragma warning( disable: 4231 )
-#endif // _LIBCPP_MSVC
_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __basic_string_common<true>)
-#ifdef _LIBCPP_MSVC
-#pragma warning( pop )
-#endif // _LIBCPP_MSVC
#ifdef _LIBCPP_NO_EXCEPTIONS
template <class _Iter>
@@ -675,12 +670,12 @@
size_type __cap_;
};
-#if _LIBCPP_BIG_ENDIAN
- enum {__short_mask = 0x01};
- enum {__long_mask = 0x1ul};
+#ifdef _LIBCPP_BIG_ENDIAN
+ static const size_type __short_mask = 0x01;
+ static const size_type __long_mask = 0x1ul;
#else // _LIBCPP_BIG_ENDIAN
- enum {__short_mask = 0x80};
- enum {__long_mask = ~(size_type(~0) >> 1)};
+ static const size_type __short_mask = 0x80;
+ static const size_type __long_mask = ~(size_type(~0) >> 1);
#endif // _LIBCPP_BIG_ENDIAN
enum {__min_cap = (sizeof(__long) - 1)/sizeof(value_type) > 2 ?
@@ -705,12 +700,12 @@
pointer __data_;
};
-#if _LIBCPP_BIG_ENDIAN
- enum {__short_mask = 0x80};
- enum {__long_mask = ~(size_type(~0) >> 1)};
+#ifdef _LIBCPP_BIG_ENDIAN
+ static const size_type __short_mask = 0x80;
+ static const size_type __long_mask = ~(size_type(~0) >> 1);
#else // _LIBCPP_BIG_ENDIAN
- enum {__short_mask = 0x01};
- enum {__long_mask = 0x1ul};
+ static const size_type __short_mask = 0x01;
+ static const size_type __long_mask = 0x1ul;
#endif // _LIBCPP_BIG_ENDIAN
enum {__min_cap = (sizeof(__long) - 1)/sizeof(value_type) > 2 ?
@@ -1152,7 +1147,7 @@
_LIBCPP_INLINE_VISIBILITY
size_type rfind(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY
- size_type rfind(__self_view __sv, size_type __pos = 0) const _NOEXCEPT;
+ size_type rfind(__self_view __sv, size_type __pos = npos) const _NOEXCEPT;
size_type rfind(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY
size_type rfind(const value_type* __s, size_type __pos = npos) const _NOEXCEPT;
@@ -1171,7 +1166,7 @@
_LIBCPP_INLINE_VISIBILITY
size_type find_last_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY
- size_type find_last_of(__self_view __sv, size_type __pos = 0) const _NOEXCEPT;
+ size_type find_last_of(__self_view __sv, size_type __pos = npos) const _NOEXCEPT;
size_type find_last_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY
size_type find_last_of(const value_type* __s, size_type __pos = npos) const _NOEXCEPT;
@@ -1191,7 +1186,7 @@
_LIBCPP_INLINE_VISIBILITY
size_type find_last_not_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY
- size_type find_last_not_of(__self_view __sv, size_type __pos = 0) const _NOEXCEPT;
+ size_type find_last_not_of(__self_view __sv, size_type __pos = npos) const _NOEXCEPT;
size_type find_last_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY
size_type find_last_not_of(const value_type* __s, size_type __pos = npos) const _NOEXCEPT;
@@ -1246,7 +1241,7 @@
_LIBCPP_INLINE_VISIBILITY
void __set_short_size(size_type __s) _NOEXCEPT
-# if _LIBCPP_BIG_ENDIAN
+# ifdef _LIBCPP_BIG_ENDIAN
{__r_.first().__s.__size_ = (unsigned char)(__s << 1);}
# else
{__r_.first().__s.__size_ = (unsigned char)(__s);}
@@ -1254,7 +1249,7 @@
_LIBCPP_INLINE_VISIBILITY
size_type __get_short_size() const _NOEXCEPT
-# if _LIBCPP_BIG_ENDIAN
+# ifdef _LIBCPP_BIG_ENDIAN
{return __r_.first().__s.__size_ >> 1;}
# else
{return __r_.first().__s.__size_;}
@@ -1264,7 +1259,7 @@
_LIBCPP_INLINE_VISIBILITY
void __set_short_size(size_type __s) _NOEXCEPT
-# if _LIBCPP_BIG_ENDIAN
+# ifdef _LIBCPP_BIG_ENDIAN
{__r_.first().__s.__size_ = (unsigned char)(__s);}
# else
{__r_.first().__s.__size_ = (unsigned char)(__s << 1);}
@@ -1272,7 +1267,7 @@
_LIBCPP_INLINE_VISIBILITY
size_type __get_short_size() const _NOEXCEPT
-# if _LIBCPP_BIG_ENDIAN
+# ifdef _LIBCPP_BIG_ENDIAN
{return __r_.first().__s.__size_;}
# else
{return __r_.first().__s.__size_ >> 1;}
@@ -2875,7 +2870,7 @@
basic_string<_CharT, _Traits, _Allocator>::max_size() const _NOEXCEPT
{
size_type __m = __alloc_traits::max_size(__alloc());
-#if _LIBCPP_BIG_ENDIAN
+#ifdef _LIBCPP_BIG_ENDIAN
return (__m <= ~__long_mask ? __m : __m/2) - __alignment;
#else
return __m - __alignment;
@@ -4004,6 +3999,9 @@
#endif // _LIBCPP_DEBUG_LEVEL >= 2
+_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_string<char>)
+_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_string<wchar_t>)
+
#if _LIBCPP_STD_VER > 11
// Literal suffixes for basic_string [basic.string.literals]
inline namespace literals
@@ -4037,10 +4035,6 @@
}
#endif
-_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_string<char>)
-_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_string<wchar_t>)
-_LIBCPP_EXTERN_TEMPLATE(string operator+<char, char_traits<char>, allocator<char> >(char const*, string const&))
-
_LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS
diff --git a/include/support/win32/locale_win32.h b/include/support/win32/locale_win32.h
index b2b3ac4..113c107 100644
--- a/include/support/win32/locale_win32.h
+++ b/include/support/win32/locale_win32.h
@@ -100,7 +100,11 @@
#define iswxdigit_l _iswxdigit_l
#define towupper_l _towupper_l
#define towlower_l _towlower_l
+#if defined(__MINGW32__) && __MSVCRT_VERSION__ < 0x0800
+#define strftime_l( __s, __l, __f, __tm, __loc ) strftime( __s, __l, __f, __tm )
+#else
#define strftime_l _strftime_l
+#endif
#define sscanf_l( __s, __l, __f, ...) _sscanf_l( __s, __f, __l, __VA_ARGS__ )
#define vsscanf_l( __s, __l, __f, ...) _sscanf_l( __s, __f, __l, __VA_ARGS__ )
#define sprintf_l( __s, __l, __f, ... ) _sprintf_l( __s, __f, __l, __VA_ARGS__ )
diff --git a/include/system_error b/include/system_error
index a29807d..1274552 100644
--- a/include/system_error
+++ b/include/system_error
@@ -230,6 +230,7 @@
#include <type_traits>
#include <stdexcept>
#include <__functional_base>
+#include <string>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
diff --git a/include/tuple b/include/tuple
index a52b934..788fd75 100644
--- a/include/tuple
+++ b/include/tuple
@@ -929,7 +929,7 @@
void swap(tuple&) _NOEXCEPT {}
};
-#ifdef __cpp_deduction_guides
+#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
// NOTE: These are not yet standardized, but are required to simulate the
// implicit deduction guide that should be generated had libc++ declared the
// tuple-like constructors "correctly"
diff --git a/include/type_traits b/include/type_traits
index 9db4d66..6c111ab 100644
--- a/include/type_traits
+++ b/include/type_traits
@@ -4339,8 +4339,8 @@
using _Result = decltype(
_VSTD::__invoke(_VSTD::declval<_Fp>(), _VSTD::declval<_Args>()...));
- static const bool value =
- conditional<
+ using type =
+ typename conditional<
!is_same<_Result, __nat>::value,
typename conditional<
is_void<_Ret>::value,
@@ -4348,7 +4348,8 @@
is_convertible<_Result, _Ret>
>::type,
false_type
- >::type::value;
+ >::type;
+ static const bool value = type::value;
};
template <class _Fp, class ..._Args>
diff --git a/include/typeinfo b/include/typeinfo
index 8624b34..7e8d399 100644
--- a/include/typeinfo
+++ b/include/typeinfo
@@ -69,18 +69,17 @@
#pragma GCC system_header
#endif
-#if defined(_LIBCPP_ABI_MICROSOFT)
-#include <vcruntime_typeinfo.h>
-#elif defined(_LIBCPP_NONUNIQUE_RTTI_BIT)
+#if !defined(_LIBCPP_ABI_MICROSOFT)
+#if defined(_LIBCPP_NONUNIQUE_RTTI_BIT)
#define _LIBCPP_HAS_NONUNIQUE_TYPEINFO
#else
#define _LIBCPP_HAS_UNIQUE_TYPEINFO
#endif
+#endif
namespace std // purposefully not using versioning namespace
{
-#if !defined(_LIBCPP_ABI_MICROSOFT)
class _LIBCPP_EXCEPTION_ABI type_info
{
type_info& operator=(const type_info&);
@@ -92,7 +91,17 @@
{ return __builtin_strcmp(name(), __arg.name()); }
#endif
+#if defined(_LIBCPP_ABI_MICROSOFT)
+ mutable struct {
+ const char *__undecorated_name;
+ const char __decorated_name[1];
+ } __data;
+
+ int __compare(const type_info &__rhs) const _NOEXCEPT;
+#endif // _LIBCPP_ABI_MICROSOFT
+
protected:
+#if !defined(_LIBCPP_ABI_MICROSOFT)
#if defined(_LIBCPP_HAS_NONUNIQUE_TYPEINFO)
// A const char* with the non-unique RTTI bit possibly set.
uintptr_t __type_name;
@@ -106,11 +115,27 @@
_LIBCPP_INLINE_VISIBILITY
explicit type_info(const char* __n) : __type_name(__n) {}
#endif
+#endif // ! _LIBCPP_ABI_MICROSOFT
public:
_LIBCPP_AVAILABILITY_TYPEINFO_VTABLE
virtual ~type_info();
+#if defined(_LIBCPP_ABI_MICROSOFT)
+ const char *name() const _NOEXCEPT;
+
+ _LIBCPP_INLINE_VISIBILITY
+ bool before(const type_info& __arg) const _NOEXCEPT {
+ return __compare(__arg) < 0;
+ }
+
+ size_t hash_code() const _NOEXCEPT;
+
+ _LIBCPP_INLINE_VISIBILITY
+ bool operator==(const type_info& __arg) const _NOEXCEPT {
+ return __compare(__arg) == 0;
+ }
+#else
#if defined(_LIBCPP_HAS_NONUNIQUE_TYPEINFO)
_LIBCPP_INLINE_VISIBILITY
const char* name() const _NOEXCEPT
@@ -167,6 +192,7 @@
bool operator==(const type_info& __arg) const _NOEXCEPT
{ return __type_name == __arg.__type_name; }
#endif
+#endif // _LIBCPP_ABI_MICROSOFT
_LIBCPP_INLINE_VISIBILITY
bool operator!=(const type_info& __arg) const _NOEXCEPT
@@ -191,8 +217,6 @@
virtual const char* what() const _NOEXCEPT;
};
-#endif // !_LIBCPP_ABI_MICROSOFT
-
} // std
_LIBCPP_BEGIN_NAMESPACE_STD
diff --git a/include/utility b/include/utility
index 00e3cd2..288c6e8 100644
--- a/include/utility
+++ b/include/utility
@@ -545,6 +545,11 @@
#endif
};
+#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
+template<class _T1, class _T2>
+pair(_T1, _T2) -> pair<_T1, _T2>;
+#endif // _LIBCPP_HAS_NO_DEDUCTION_GUIDES
+
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
bool
diff --git a/include/variant b/include/variant
index 8711ef6..f8d3e28 100644
--- a/include/variant
+++ b/include/variant
@@ -1116,6 +1116,8 @@
template <
class _Arg,
enable_if_t<!is_same_v<decay_t<_Arg>, variant>, int> = 0,
+ enable_if_t<!__is_inplace_type<decay_t<_Arg>>::value, int> = 0,
+ enable_if_t<!__is_inplace_index<decay_t<_Arg>>::value, int> = 0,
class _Tp = __variant_detail::__best_match_t<_Arg, _Types...>,
size_t _Ip =
__find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
diff --git a/include/vector b/include/vector
index ee19fb7..b2f8f09 100644
--- a/include/vector
+++ b/include/vector
@@ -310,14 +310,7 @@
_VSTD::__throw_out_of_range("vector");
}
-#ifdef _LIBCPP_MSVC
-#pragma warning( push )
-#pragma warning( disable: 4231 )
-#endif // _LIBCPP_MSVC
_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __vector_base_common<true>)
-#ifdef _LIBCPP_MSVC
-#pragma warning( pop )
-#endif // _LIBCPP_MSVC
template <class _Tp, class _Allocator>
class __vector_base
@@ -681,6 +674,17 @@
const value_type* data() const _NOEXCEPT
{return _VSTD::__to_raw_pointer(this->__begin_);}
+#ifdef _LIBCPP_CXX03_LANG
+ _LIBCPP_INLINE_VISIBILITY
+ void __emplace_back(const value_type& __x) { push_back(__x); }
+#else
+ template <class _Arg>
+ _LIBCPP_INLINE_VISIBILITY
+ void __emplace_back(_Arg&& __arg) {
+ emplace_back(_VSTD::forward<_Arg>(__arg));
+ }
+#endif
+
_LIBCPP_INLINE_VISIBILITY void push_back(const_reference __x);
#ifndef _LIBCPP_CXX03_LANG
@@ -1135,7 +1139,7 @@
__get_db()->__insert_c(this);
#endif
for (; __first != __last; ++__first)
- push_back(*__first);
+ __emplace_back(*__first);
}
template <class _Tp, class _Allocator>
@@ -1152,7 +1156,7 @@
__get_db()->__insert_c(this);
#endif
for (; __first != __last; ++__first)
- push_back(*__first);
+ __emplace_back(*__first);
}
template <class _Tp, class _Allocator>
@@ -1372,7 +1376,7 @@
{
clear();
for (; __first != __last; ++__first)
- push_back(*__first);
+ __emplace_back(*__first);
}
template <class _Tp, class _Allocator>
diff --git a/include/wchar.h b/include/wchar.h
index a5666e1..f74fe6d 100644
--- a/include/wchar.h
+++ b/include/wchar.h
@@ -125,6 +125,10 @@
# if __GLIBC_PREREQ(2, 10)
# define _LIBCPP_WCHAR_H_HAS_CONST_OVERLOADS 1
# endif
+#elif defined(_LIBCPP_MSVCRT)
+# if defined(_CRT_CONST_CORRECT_OVERLOADS)
+# define _LIBCPP_WCHAR_H_HAS_CONST_OVERLOADS 1
+# endif
#endif
#if defined(__cplusplus) && !defined(_LIBCPP_WCHAR_H_HAS_CONST_OVERLOADS) && defined(_LIBCPP_PREFERRED_OVERLOAD)
diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
index f04ef82..6f574cc 100644
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -91,6 +91,7 @@
add_library_flags_if(LIBCXX_HAS_GCC_S_LIB gcc_s)
endif()
add_library_flags_if(LIBCXX_HAVE_CXX_ATOMICS_WITH_LIB atomic)
+add_library_flags_if(MINGW "${MINGW_LIBRARIES}")
# Add the unwinder library.
if (LIBCXXABI_USE_LLVM_UNWINDER)
@@ -258,7 +259,7 @@
set(MERGE_ARCHIVES_SEARCH_PATHS "-L${LIBCXX_CXX_ABI_LIBRARY_PATH}")
endif()
if ((TARGET ${LIBCXX_CXX_ABI_LIBRARY}) OR
- (${LIBCXX_CXX_ABI_LIBRARY} STREQUAL "cxxabi(_static|_shared)?" AND HAVE_LIBCXXABI))
+ (${LIBCXX_CXX_ABI_LIBRARY} MATCHES "cxxabi(_static|_shared)?" AND HAVE_LIBCXXABI))
set(MERGE_ARCHIVES_ABI_TARGET "$<TARGET_LINKER_FILE:${LIBCXX_CXX_ABI_LIBRARY}>")
else()
set(MERGE_ARCHIVES_ABI_TARGET
@@ -269,6 +270,7 @@
${PYTHON_EXECUTABLE} ${LIBCXX_SOURCE_DIR}/utils/merge_archives.py
ARGS
-o $<TARGET_LINKER_FILE:cxx_static>
+ --ar "${CMAKE_AR}"
"$<TARGET_LINKER_FILE:cxx_static>"
"${MERGE_ARCHIVES_ABI_TARGET}"
"${MERGE_ARCHIVES_SEARCH_PATHS}"
@@ -355,8 +357,8 @@
set(experimental_lib cxx_experimental)
endif()
install(TARGETS ${LIBCXX_TARGETS} ${experimental_lib}
- LIBRARY DESTINATION lib${LIBCXX_LIBDIR_SUFFIX} COMPONENT cxx
- ARCHIVE DESTINATION lib${LIBCXX_LIBDIR_SUFFIX} COMPONENT cxx
+ LIBRARY DESTINATION ${LIBCXX_INSTALL_PREFIX}lib${LIBCXX_LIBDIR_SUFFIX} COMPONENT cxx
+ ARCHIVE DESTINATION ${LIBCXX_INSTALL_PREFIX}lib${LIBCXX_LIBDIR_SUFFIX} COMPONENT cxx
)
# NOTE: This install command must go after the cxx install command otherwise
# it will not be executed after the library symlinks are installed.
@@ -364,7 +366,7 @@
# Replace the libc++ filename with $<TARGET_LINKER_FILE:cxx>
# after we required CMake 3.0.
install(FILES "${LIBCXX_LIBRARY_DIR}/libc++${CMAKE_SHARED_LIBRARY_SUFFIX}"
- DESTINATION lib${LIBCXX_LIBDIR_SUFFIX}
+ DESTINATION ${LIBCXX_INSTALL_PREFIX}lib${LIBCXX_LIBDIR_SUFFIX}
COMPONENT libcxx)
endif()
endif()
diff --git a/lib/abi/CHANGELOG.TXT b/lib/abi/CHANGELOG.TXT
index b979b46..b8a0cbe 100644
--- a/lib/abi/CHANGELOG.TXT
+++ b/lib/abi/CHANGELOG.TXT
@@ -16,6 +16,16 @@
Version 5.0
-----------
+* r313500 - Fix undefined "___cxa_deleted_virtual" symbol in macosx
+
+ x86_64-linux-gnu
+ ----------------
+ No changes
+
+ x86_64-apple-darwin16.0
+ -----------------------
+ Symbol added: ___cxa_deleted_virtual
+
* r296729 - Remove std::num_get template methods which should be inline
These functions should never have had visible definitions in the dylib but
diff --git a/lib/abi/x86_64-apple-darwin16.abilist b/lib/abi/x86_64-apple-darwin16.abilist
index 5d91c4b..4e212b1 100644
--- a/lib/abi/x86_64-apple-darwin16.abilist
+++ b/lib/abi/x86_64-apple-darwin16.abilist
@@ -2323,6 +2323,8 @@
{'type': 'I', 'is_defined': True, 'name': '___cxa_current_exception_type'}
{'type': 'U', 'is_defined': False, 'name': '___cxa_current_primary_exception'}
{'type': 'U', 'is_defined': False, 'name': '___cxa_decrement_exception_refcount'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_deleted_virtual'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_deleted_virtual'}
{'type': 'U', 'is_defined': False, 'name': '___cxa_demangle'}
{'type': 'I', 'is_defined': True, 'name': '___cxa_demangle'}
{'type': 'U', 'is_defined': False, 'name': '___cxa_end_catch'}
diff --git a/lib/libc++abi.exp b/lib/libc++abi.exp
index 87035b2..879b4dd 100644
--- a/lib/libc++abi.exp
+++ b/lib/libc++abi.exp
@@ -12,6 +12,7 @@
___cxa_guard_release
___cxa_rethrow
___cxa_pure_virtual
+___cxa_deleted_virtual
___cxa_begin_catch
___cxa_throw
___cxa_vec_cctor
diff --git a/lib/libc++abi2.exp b/lib/libc++abi2.exp
index eb088f3..0059eb4 100644
--- a/lib/libc++abi2.exp
+++ b/lib/libc++abi2.exp
@@ -12,6 +12,7 @@
___cxa_guard_release
___cxa_rethrow
___cxa_pure_virtual
+___cxa_deleted_virtual
___cxa_begin_catch
___cxa_throw
___cxa_vec_cctor
diff --git a/lib/libc++sjlj-abi.exp b/lib/libc++sjlj-abi.exp
index e646df1..f494e17 100644
--- a/lib/libc++sjlj-abi.exp
+++ b/lib/libc++sjlj-abi.exp
@@ -12,6 +12,7 @@
___cxa_guard_release
___cxa_rethrow
___cxa_pure_virtual
+___cxa_deleted_virtual
___cxa_begin_catch
___cxa_throw
___cxa_vec_cctor
diff --git a/src/exception.cpp b/src/exception.cpp
index 4359d12..3d2dcfd 100644
--- a/src/exception.cpp
+++ b/src/exception.cpp
@@ -31,6 +31,7 @@
#include "support/runtime/exception_glibcxx.ipp"
#include "support/runtime/exception_pointer_glibcxx.ipp"
#else
+#include "include/atomic_support.h"
#include "support/runtime/exception_fallback.ipp"
#include "support/runtime/exception_pointer_unimplemented.ipp"
#endif
diff --git a/src/experimental/filesystem/filesystem_time_helper.h b/src/experimental/filesystem/filesystem_time_helper.h
new file mode 100644
index 0000000..a60fdef
--- /dev/null
+++ b/src/experimental/filesystem/filesystem_time_helper.h
@@ -0,0 +1,173 @@
+//===----------------------------------------------------------------------===////
+//
+// The 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 FILESYSTEM_TIME_HELPER_H
+#define FILESYSTEM_TIME_HELPER_H
+
+#include "experimental/__config"
+#include "chrono"
+#include "cstdlib"
+#include "climits"
+
+#include <unistd.h>
+#include <sys/stat.h>
+#if !defined(UTIME_OMIT)
+#include <sys/time.h> // for ::utimes as used in __last_write_time
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM
+
+namespace time_detail { namespace {
+
+using namespace chrono;
+
+template <class FileTimeT,
+ bool IsFloat = is_floating_point<typename FileTimeT::rep>::value>
+struct fs_time_util_base {
+ static constexpr auto max_seconds =
+ duration_cast<seconds>(FileTimeT::duration::max()).count();
+
+ static constexpr auto max_nsec =
+ duration_cast<nanoseconds>(FileTimeT::duration::max() -
+ seconds(max_seconds))
+ .count();
+
+ static constexpr auto min_seconds =
+ duration_cast<seconds>(FileTimeT::duration::min()).count();
+
+ static constexpr auto min_nsec_timespec =
+ duration_cast<nanoseconds>(
+ (FileTimeT::duration::min() - seconds(min_seconds)) + seconds(1))
+ .count();
+
+ // Static assert that these values properly round trip.
+ static_assert((seconds(min_seconds) +
+ duration_cast<microseconds>(nanoseconds(min_nsec_timespec))) -
+ duration_cast<microseconds>(seconds(1)) ==
+ FileTimeT::duration::min(),
+ "");
+};
+
+template <class FileTimeT>
+struct fs_time_util_base<FileTimeT, true> {
+ static const long long max_seconds;
+ static const long long max_nsec;
+ static const long long min_seconds;
+ static const long long min_nsec_timespec;
+};
+
+template <class FileTimeT>
+const long long fs_time_util_base<FileTimeT, true>::max_seconds =
+ duration_cast<seconds>(FileTimeT::duration::max()).count();
+
+template <class FileTimeT>
+const long long fs_time_util_base<FileTimeT, true>::max_nsec =
+ duration_cast<nanoseconds>(FileTimeT::duration::max() -
+ seconds(max_seconds))
+ .count();
+
+template <class FileTimeT>
+const long long fs_time_util_base<FileTimeT, true>::min_seconds =
+ duration_cast<seconds>(FileTimeT::duration::min()).count();
+
+template <class FileTimeT>
+const long long fs_time_util_base<FileTimeT, true>::min_nsec_timespec =
+ duration_cast<nanoseconds>((FileTimeT::duration::min() -
+ seconds(min_seconds)) +
+ seconds(1))
+ .count();
+
+template <class FileTimeT, class TimeT, class TimeSpecT>
+struct fs_time_util : fs_time_util_base<FileTimeT> {
+ using Base = fs_time_util_base<FileTimeT>;
+ using Base::max_nsec;
+ using Base::max_seconds;
+ using Base::min_nsec_timespec;
+ using Base::min_seconds;
+
+public:
+ template <class CType, class ChronoType>
+ static 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;
+ }
+
+ static _LIBCPP_CONSTEXPR_AFTER_CXX11 bool is_representable(TimeSpecT tm) {
+ if (tm.tv_sec >= 0) {
+ return (tm.tv_sec < max_seconds) ||
+ (tm.tv_sec == max_seconds && tm.tv_nsec <= max_nsec);
+ } else if (tm.tv_sec == (min_seconds - 1)) {
+ return tm.tv_nsec >= min_nsec_timespec;
+ } else {
+ return (tm.tv_sec >= min_seconds);
+ }
+ }
+
+ static _LIBCPP_CONSTEXPR_AFTER_CXX11 bool is_representable(FileTimeT tm) {
+ auto secs = duration_cast<seconds>(tm.time_since_epoch());
+ auto nsecs = duration_cast<nanoseconds>(tm.time_since_epoch() - secs);
+ if (nsecs.count() < 0) {
+ secs = secs + seconds(1);
+ nsecs = nsecs + seconds(1);
+ }
+ using TLim = numeric_limits<TimeT>;
+ if (secs.count() >= 0)
+ return secs.count() <= TLim::max();
+ return secs.count() >= TLim::min();
+ }
+
+ static _LIBCPP_CONSTEXPR_AFTER_CXX11 FileTimeT
+ convert_timespec(TimeSpecT tm) {
+ auto adj_msec = duration_cast<microseconds>(nanoseconds(tm.tv_nsec));
+ if (tm.tv_sec >= 0) {
+ auto Dur = seconds(tm.tv_sec) + microseconds(adj_msec);
+ return FileTimeT(Dur);
+ } else if (duration_cast<microseconds>(nanoseconds(tm.tv_nsec)).count() ==
+ 0) {
+ return FileTimeT(seconds(tm.tv_sec));
+ } else { // tm.tv_sec < 0
+ auto adj_subsec =
+ duration_cast<microseconds>(seconds(1) - nanoseconds(tm.tv_nsec));
+ auto Dur = seconds(tm.tv_sec + 1) - adj_subsec;
+ return FileTimeT(Dur);
+ }
+ }
+
+ template <class SubSecDurT, class SubSecT>
+ static bool set_times_checked(TimeT* sec_out, SubSecT* subsec_out,
+ FileTimeT 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
+} // end namespace time_detail
+
+using time_detail::fs_time_util;
+
+_LIBCPP_END_NAMESPACE_EXPERIMENTAL_FILESYSTEM
+
+#endif // FILESYSTEM_TIME_HELPER_H
diff --git a/src/experimental/filesystem/operations.cpp b/src/experimental/filesystem/operations.cpp
index e9bc0eb..1a51454 100644
--- a/src/experimental/filesystem/operations.cpp
+++ b/src/experimental/filesystem/operations.cpp
@@ -15,6 +15,8 @@
#include "cstdlib"
#include "climits"
+#include "filesystem_time_helper.h"
+
#include <unistd.h>
#include <sys/stat.h>
#include <sys/statvfs.h>
@@ -180,20 +182,20 @@
const bool sym_status2 = bool(options &
copy_options::copy_symlinks);
- std::error_code m_ec;
+ std::error_code m_ec1;
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);
+ ? detail::posix_lstat(from, f_st, &m_ec1)
+ : detail::posix_stat(from, f_st, &m_ec1);
+ if (m_ec1)
+ return set_or_throw(m_ec1, 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);
+ const file_status t = sym_status ? detail::posix_lstat(to, t_st, &m_ec1)
+ : detail::posix_stat(to, t_st, &m_ec1);
if (not status_known(t))
- return set_or_throw(m_ec, ec, "copy", from, to);
+ return set_or_throw(m_ec1, ec, "copy", from, to);
if (!exists(f) || is_other(f) || is_other(t)
|| (is_directory(f) && is_regular_file(t))
@@ -247,9 +249,9 @@
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);
+ std::error_code m_ec2;
+ for (; it != directory_iterator(); it.increment(m_ec2)) {
+ if (m_ec2) return set_or_throw(m_ec2, ec, "copy", from, to);
__copy(it->path(), to / it->path().filename(),
options | copy_options::__in_recursive_copy, ec);
if (ec && *ec) { return; }
@@ -426,17 +428,20 @@
bool __equivalent(const path& p1, const path& p2, std::error_code *ec)
{
+ auto make_unsupported_error = [&]() {
+ set_or_throw(make_error_code(errc::not_supported), ec,
+ "equivalent", p1, p2);
+ return false;
+ };
std::error_code ec1, ec2;
struct ::stat st1 = {};
struct ::stat st2 = {};
auto s1 = detail::posix_stat(p1.native(), st1, &ec1);
+ if (!exists(s1))
+ return make_unsupported_error();
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 (!exists(s2))
+ return make_unsupported_error();
if (ec) ec->clear();
return (st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino);
}
@@ -502,17 +507,6 @@
namespace detail { namespace {
-using namespace std::chrono;
-
-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;
-}
-
using TimeSpec = struct timespec;
using StatT = struct stat;
@@ -525,137 +519,10 @@
TimeSpec extract_atime(StatT const& st) { return st.st_atim; }
#endif
-constexpr auto max_seconds = duration_cast<seconds>(
- file_time_type::duration::max()).count();
-
-constexpr auto max_nsec = duration_cast<nanoseconds>(
- file_time_type::duration::max() - seconds(max_seconds)).count();
-
-constexpr auto min_seconds = duration_cast<seconds>(
- file_time_type::duration::min()).count();
-
-constexpr auto min_nsec_timespec = duration_cast<nanoseconds>(
- (file_time_type::duration::min() - seconds(min_seconds)) + seconds(1)).count();
-
-// Static assert that these values properly round trip.
-static_assert((seconds(min_seconds) + duration_cast<microseconds>(nanoseconds(min_nsec_timespec)))
- - duration_cast<microseconds>(seconds(1))
- == file_time_type::duration::min(), "");
-
-constexpr auto max_time_t = numeric_limits<time_t>::max();
-constexpr auto min_time_t = numeric_limits<time_t>::min();
-
-#if !defined(__LP64__) && defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wtautological-constant-out-of-range-compare"
-#endif
-
-_LIBCPP_CONSTEXPR_AFTER_CXX11
-bool is_representable(TimeSpec const& tm) {
- if (tm.tv_sec >= 0) {
- return (tm.tv_sec < max_seconds) ||
- (tm.tv_sec == max_seconds && tm.tv_nsec <= max_nsec);
- } else if (tm.tv_sec == (min_seconds - 1)) {
- return tm.tv_nsec >= min_nsec_timespec;
- } else {
- return (tm.tv_sec >= min_seconds);
- }
-}
-#ifndef _LIBCPP_HAS_NO_CXX14_CONSTEXPR
-#if defined(__LP64__)
-static_assert(is_representable({max_seconds, max_nsec}), "");
-static_assert(!is_representable({max_seconds + 1, 0}), "");
-static_assert(!is_representable({max_seconds, max_nsec + 1}), "");
-static_assert(!is_representable({max_time_t, 0}), "");
-static_assert(is_representable({min_seconds, 0}), "");
-static_assert(is_representable({min_seconds - 1, min_nsec_timespec}), "");
-static_assert(is_representable({min_seconds - 1, min_nsec_timespec + 1}), "");
-static_assert(!is_representable({min_seconds - 1, min_nsec_timespec - 1}), "");
-static_assert(!is_representable({min_time_t, 999999999}), "");
-#else
-static_assert(is_representable({max_time_t, 999999999}), "");
-static_assert(is_representable({max_time_t, 1000000000}), "");
-static_assert(is_representable({min_time_t, 0}), "");
-#endif
-#endif
-
-_LIBCPP_CONSTEXPR_AFTER_CXX11
-bool is_representable(file_time_type const& tm) {
- auto secs = duration_cast<seconds>(tm.time_since_epoch());
- auto nsecs = duration_cast<nanoseconds>(tm.time_since_epoch() - secs);
- if (nsecs.count() < 0) {
- secs = secs + seconds(1);
- nsecs = nsecs + seconds(1);
- }
- using TLim = numeric_limits<time_t>;
- if (secs.count() >= 0)
- return secs.count() <= TLim::max();
- return secs.count() >= TLim::min();
-}
-#ifndef _LIBCPP_HAS_NO_CXX14_CONSTEXPR
-#if defined(__LP64__)
-static_assert(is_representable(file_time_type::max()), "");
-static_assert(is_representable(file_time_type::min()), "");
-#else
-static_assert(!is_representable(file_time_type::max()), "");
-static_assert(!is_representable(file_time_type::min()), "");
-static_assert(is_representable(file_time_type(seconds(max_time_t))), "");
-static_assert(is_representable(file_time_type(seconds(min_time_t))), "");
-#endif
-#endif
-
-_LIBCPP_CONSTEXPR_AFTER_CXX11
-file_time_type convert_timespec(TimeSpec const& tm) {
- auto adj_msec = duration_cast<microseconds>(nanoseconds(tm.tv_nsec));
- if (tm.tv_sec >= 0) {
- auto Dur = seconds(tm.tv_sec) + microseconds(adj_msec);
- return file_time_type(Dur);
- } else if (duration_cast<microseconds>(nanoseconds(tm.tv_nsec)).count() == 0) {
- return file_time_type(seconds(tm.tv_sec));
- } else { // tm.tv_sec < 0
- auto adj_subsec = duration_cast<microseconds>(seconds(1) - nanoseconds(tm.tv_nsec));
- auto Dur = seconds(tm.tv_sec + 1) - adj_subsec;
- return file_time_type(Dur);
- }
-}
-#ifndef _LIBCPP_HAS_NO_CXX14_CONSTEXPR
-#if defined(__LP64__)
-static_assert(convert_timespec({max_seconds, max_nsec}) == file_time_type::max(), "");
-static_assert(convert_timespec({max_seconds, max_nsec - 1}) < file_time_type::max(), "");
-static_assert(convert_timespec({max_seconds - 1, 999999999}) < file_time_type::max(), "");
-static_assert(convert_timespec({min_seconds - 1, min_nsec_timespec}) == file_time_type::min(), "");
-static_assert(convert_timespec({min_seconds - 1, min_nsec_timespec + 1}) > file_time_type::min(), "");
-static_assert(convert_timespec({min_seconds , 0}) > file_time_type::min(), "");
-#else
-// FIXME add tests for 32 bit builds
-#endif
-#endif
-
-#if !defined(__LP64__) && defined(__clang__)
-#pragma clang diagnostic pop
-#endif
-
-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
+using FSTime = fs_time_util<file_time_type, time_t, struct timespec>;
+
file_time_type __last_write_time(const path& p, std::error_code *ec)
{
using namespace ::std::chrono;
@@ -668,12 +535,12 @@
}
if (ec) ec->clear();
auto ts = detail::extract_mtime(st);
- if (!detail::is_representable(ts)) {
+ if (!FSTime::is_representable(ts)) {
set_or_throw(error_code(EOVERFLOW, generic_category()), ec,
"last_write_time", p);
return file_time_type::min();
}
- return detail::convert_timespec(ts);
+ return FSTime::convert_timespec(ts);
}
void __last_write_time(const path& p, file_time_type new_time,
@@ -698,7 +565,7 @@
struct ::timeval tbuf[2];
tbuf[0].tv_sec = atime.tv_sec;
tbuf[0].tv_usec = duration_cast<microseconds>(nanoseconds(atime.tv_nsec)).count();
- const bool overflowed = !detail::set_times_checked<microseconds>(
+ const bool overflowed = !FSTime::set_times_checked<microseconds>(
&tbuf[1].tv_sec, &tbuf[1].tv_usec, new_time);
if (overflowed) {
@@ -714,7 +581,7 @@
tbuf[0].tv_sec = 0;
tbuf[0].tv_nsec = UTIME_OMIT;
- const bool overflowed = !detail::set_times_checked<nanoseconds>(
+ const bool overflowed = !FSTime::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),
diff --git a/src/experimental/filesystem/path.cpp b/src/experimental/filesystem/path.cpp
index f49d4cd..dd4026c 100644
--- a/src/experimental/filesystem/path.cpp
+++ b/src/experimental/filesystem/path.cpp
@@ -261,7 +261,8 @@
string_view_pair separate_filename(string_view_t const & s) {
if (s == "." || s == ".." || s.empty()) return string_view_pair{s, ""};
auto pos = s.find_last_of('.');
- if (pos == string_view_t::npos) return string_view_pair{s, string_view{}};
+ if (pos == string_view_t::npos)
+ return string_view_pair{s, string_view_t{}};
return string_view_pair{s.substr(0, pos), s.substr(pos)};
}
@@ -396,7 +397,7 @@
size_t hash_value(const path& __p) noexcept {
auto PP = PathParser::CreateBegin(__p.native());
size_t hash_value = 0;
- std::hash<string_view> hasher;
+ std::hash<string_view_t> hasher;
while (PP) {
hash_value = __hash_combine(hash_value, hasher(*PP));
++PP;
diff --git a/src/include/atomic_support.h b/src/include/atomic_support.h
index 08847e6..ccd8d78 100644
--- a/src/include/atomic_support.h
+++ b/src/include/atomic_support.h
@@ -16,6 +16,7 @@
#if defined(__clang__) && __has_builtin(__atomic_load_n) \
&& __has_builtin(__atomic_store_n) \
&& __has_builtin(__atomic_add_fetch) \
+ && __has_builtin(__atomic_exchange_n) \
&& __has_builtin(__atomic_compare_exchange_n) \
&& defined(__ATOMIC_RELAXED) \
&& defined(__ATOMIC_CONSUME) \
@@ -84,6 +85,14 @@
template <class _ValueType>
inline _LIBCPP_INLINE_VISIBILITY
+_ValueType __libcpp_atomic_exchange(_ValueType* __target,
+ _ValueType __value, int __order = _AO_Seq)
+{
+ return __atomic_exchange_n(__target, __value, __order);
+}
+
+template <class _ValueType>
+inline _LIBCPP_INLINE_VISIBILITY
bool __libcpp_atomic_compare_exchange(_ValueType* __val,
_ValueType* __expected, _ValueType __after,
int __success_order = _AO_Seq,
@@ -137,6 +146,16 @@
template <class _ValueType>
inline _LIBCPP_INLINE_VISIBILITY
+_ValueType __libcpp_atomic_exchange(_ValueType* __target,
+ _ValueType __value, int __order = _AO_Seq)
+{
+ _ValueType old = *__target;
+ *__target = __value;
+ return old;
+}
+
+template <class _ValueType>
+inline _LIBCPP_INLINE_VISIBILITY
bool __libcpp_atomic_compare_exchange(_ValueType* __val,
_ValueType* __expected, _ValueType __after,
int = 0, int = 0)
diff --git a/include/__refstring b/src/include/refstring.h
similarity index 87%
rename from include/__refstring
rename to src/include/refstring.h
index 7f417a0..702f2b7 100644
--- a/include/__refstring
+++ b/src/include/refstring.h
@@ -7,8 +7,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef _LIBCPP___REFSTRING
-#define _LIBCPP___REFSTRING
+#ifndef _LIBCPP_REFSTRING_H
+#define _LIBCPP_REFSTRING_H
#include <__config>
#include <stdexcept>
@@ -18,6 +18,7 @@
#include <dlfcn.h>
#include <mach-o/dyld.h>
#endif
+#include "atomic_support.h"
_LIBCPP_BEGIN_NAMESPACE_STD
@@ -83,7 +84,7 @@
: __imp_(s.__imp_)
{
if (__uses_refcount())
- __sync_add_and_fetch(&rep_from_data(__imp_)->count, 1);
+ __libcpp_atomic_add(&rep_from_data(__imp_)->count, 1);
}
inline
@@ -92,10 +93,10 @@
struct _Rep_base *old_rep = rep_from_data(__imp_);
__imp_ = s.__imp_;
if (__uses_refcount())
- __sync_add_and_fetch(&rep_from_data(__imp_)->count, 1);
+ __libcpp_atomic_add(&rep_from_data(__imp_)->count, 1);
if (adjust_old_count)
{
- if (__sync_add_and_fetch(&old_rep->count, count_t(-1)) < 0)
+ if (__libcpp_atomic_add(&old_rep->count, count_t(-1)) < 0)
{
::operator delete(old_rep);
}
@@ -107,7 +108,7 @@
__libcpp_refstring::~__libcpp_refstring() {
if (__uses_refcount()) {
_Rep_base* rep = rep_from_data(__imp_);
- if (__sync_add_and_fetch(&rep->count, count_t(-1)) < 0) {
+ if (__libcpp_atomic_add(&rep->count, count_t(-1)) < 0) {
::operator delete(rep);
}
}
@@ -124,4 +125,4 @@
_LIBCPP_END_NAMESPACE_STD
-#endif //_LIBCPP___REFSTRING
+#endif //_LIBCPP_REFSTRING_H
diff --git a/src/iostream.cpp b/src/iostream.cpp
index 534b47a..2b47cf2 100644
--- a/src/iostream.cpp
+++ b/src/iostream.cpp
@@ -11,19 +11,23 @@
#include "string"
#include "new"
+#define _str(s) #s
+#define str(s) _str(s)
+#define _LIBCPP_NAMESPACE_STR str(_LIBCPP_NAMESPACE)
+
_LIBCPP_BEGIN_NAMESPACE_STD
#ifndef _LIBCPP_HAS_NO_STDIN
_ALIGNAS_TYPE (istream) _LIBCPP_FUNC_VIS char cin[sizeof(istream)]
#if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
-__asm__("?cin@__1@std@@3V?$basic_istream@DU?$char_traits@D@__1@std@@@12@A")
+__asm__("?cin@" _LIBCPP_NAMESPACE_STR "@std@@3V?$basic_istream@DU?$char_traits@D@" _LIBCPP_NAMESPACE_STR "@std@@@12@A")
#endif
;
_ALIGNAS_TYPE (__stdinbuf<char> ) static char __cin[sizeof(__stdinbuf <char>)];
static mbstate_t mb_cin;
_ALIGNAS_TYPE (wistream) _LIBCPP_FUNC_VIS char wcin[sizeof(wistream)]
#if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
-__asm__("?wcin@__1@std@@3V?$basic_istream@_WU?$char_traits@_W@__1@std@@@12@A")
+__asm__("?wcin@" _LIBCPP_NAMESPACE_STR "@std@@3V?$basic_istream@_WU?$char_traits@_W@" _LIBCPP_NAMESPACE_STR "@std@@@12@A")
#endif
;
_ALIGNAS_TYPE (__stdinbuf<wchar_t> ) static char __wcin[sizeof(__stdinbuf <wchar_t>)];
@@ -33,14 +37,14 @@
#ifndef _LIBCPP_HAS_NO_STDOUT
_ALIGNAS_TYPE (ostream) _LIBCPP_FUNC_VIS char cout[sizeof(ostream)]
#if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
-__asm__("?cout@__1@std@@3V?$basic_ostream@DU?$char_traits@D@__1@std@@@12@A")
+__asm__("?cout@" _LIBCPP_NAMESPACE_STR "@std@@3V?$basic_ostream@DU?$char_traits@D@" _LIBCPP_NAMESPACE_STR "@std@@@12@A")
#endif
;
_ALIGNAS_TYPE (__stdoutbuf<char>) static char __cout[sizeof(__stdoutbuf<char>)];
static mbstate_t mb_cout;
_ALIGNAS_TYPE (wostream) _LIBCPP_FUNC_VIS char wcout[sizeof(wostream)]
#if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
-__asm__("?wcout@__1@std@@3V?$basic_ostream@_WU?$char_traits@_W@__1@std@@@12@A")
+__asm__("?wcout@" _LIBCPP_NAMESPACE_STR "@std@@3V?$basic_ostream@_WU?$char_traits@_W@" _LIBCPP_NAMESPACE_STR "@std@@@12@A")
#endif
;
_ALIGNAS_TYPE (__stdoutbuf<wchar_t>) static char __wcout[sizeof(__stdoutbuf<wchar_t>)];
@@ -49,14 +53,14 @@
_ALIGNAS_TYPE (ostream) _LIBCPP_FUNC_VIS char cerr[sizeof(ostream)]
#if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
-__asm__("?cerr@__1@std@@3V?$basic_ostream@DU?$char_traits@D@__1@std@@@12@A")
+__asm__("?cerr@" _LIBCPP_NAMESPACE_STR "@std@@3V?$basic_ostream@DU?$char_traits@D@" _LIBCPP_NAMESPACE_STR "@std@@@12@A")
#endif
;
_ALIGNAS_TYPE (__stdoutbuf<char>) static char __cerr[sizeof(__stdoutbuf<char>)];
static mbstate_t mb_cerr;
_ALIGNAS_TYPE (wostream) _LIBCPP_FUNC_VIS char wcerr[sizeof(wostream)]
#if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
-__asm__("?wcerr@__1@std@@3V?$basic_ostream@_WU?$char_traits@_W@__1@std@@@12@A")
+__asm__("?wcerr@" _LIBCPP_NAMESPACE_STR "@std@@3V?$basic_ostream@_WU?$char_traits@_W@" _LIBCPP_NAMESPACE_STR "@std@@@12@A")
#endif
;
_ALIGNAS_TYPE (__stdoutbuf<wchar_t>) static char __wcerr[sizeof(__stdoutbuf<wchar_t>)];
@@ -64,12 +68,12 @@
_ALIGNAS_TYPE (ostream) _LIBCPP_FUNC_VIS char clog[sizeof(ostream)]
#if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
-__asm__("?clog@__1@std@@3V?$basic_ostream@DU?$char_traits@D@__1@std@@@12@A")
+__asm__("?clog@" _LIBCPP_NAMESPACE_STR "@std@@3V?$basic_ostream@DU?$char_traits@D@" _LIBCPP_NAMESPACE_STR "@std@@@12@A")
#endif
;
_ALIGNAS_TYPE (wostream) _LIBCPP_FUNC_VIS char wclog[sizeof(wostream)]
#if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
-__asm__("?wclog@__1@std@@3V?$basic_ostream@_WU?$char_traits@_W@__1@std@@@12@A")
+__asm__("?wclog@" _LIBCPP_NAMESPACE_STR "@std@@3V?$basic_ostream@_WU?$char_traits@_W@" _LIBCPP_NAMESPACE_STR "@std@@@12@A")
#endif
;
diff --git a/src/locale.cpp b/src/locale.cpp
index 3b4c83a..a6cb0e9 100644
--- a/src/locale.cpp
+++ b/src/locale.cpp
@@ -36,6 +36,7 @@
#endif
#include <stdlib.h>
#include <stdio.h>
+#include "include/atomic_support.h"
#include "__undef_macros"
// On Linux, wint_t and wchar_t have different signed-ness, and this causes
@@ -667,7 +668,7 @@
void
locale::id::__init()
{
- __id_ = __sync_add_and_fetch(&__next_id, 1);
+ __id_ = __libcpp_atomic_add(&__next_id, 1);
}
// template <> class collate_byname<char>
diff --git a/src/new.cpp b/src/new.cpp
index 2b2682f..e228a0d 100644
--- a/src/new.cpp
+++ b/src/new.cpp
@@ -12,9 +12,12 @@
#include <stdlib.h>
#include "new"
+#include "include/atomic_support.h"
#if defined(_LIBCPP_ABI_MICROSOFT)
-// nothing todo
+#if defined(_LIBCPP_NO_VCRUNTIME)
+#include "support/runtime/new_handler_fallback.ipp"
+#endif
#elif defined(LIBCXX_BUILDING_LIBCXXABI)
#include <cxxabi.h>
#elif defined(LIBCXXRT)
@@ -53,7 +56,8 @@
} // std
-#if !defined(__GLIBCXX__) && !defined(_LIBCPP_ABI_MICROSOFT) && \
+#if !defined(__GLIBCXX__) && \
+ (!defined(_LIBCPP_ABI_MICROSOFT) || defined(_LIBCPP_NO_VCRUNTIME)) && \
!defined(_LIBCPP_DISABLE_NEW_DELETE_DEFINITIONS)
// Implement all new and delete operators as weak definitions
@@ -299,4 +303,4 @@
}
#endif // !_LIBCPP_HAS_NO_ALIGNED_ALLOCATION
-#endif // !__GLIBCXX__ && !_LIBCPP_ABI_MICROSOFT && !_LIBCPP_DISABLE_NEW_DELETE_DEFINITIONS
+#endif // !__GLIBCXX__ && (!_LIBCPP_ABI_MICROSOFT || _LIBCPP_NO_VCRUNTIME) && !_LIBCPP_DISABLE_NEW_DELETE_DEFINITIONS
diff --git a/src/stdexcept.cpp b/src/stdexcept.cpp
index 3f33330..5e06e52 100644
--- a/src/stdexcept.cpp
+++ b/src/stdexcept.cpp
@@ -11,7 +11,7 @@
#include "new"
#include "string"
#include "system_error"
-#include "__refstring"
+#include "include/refstring.h"
/* For _LIBCPPABI_VERSION */
#if !defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY) && \
diff --git a/src/strstream.cpp b/src/strstream.cpp
index 01523cf..8b8521f 100644
--- a/src/strstream.cpp
+++ b/src/strstream.cpp
@@ -186,7 +186,7 @@
}
setg(buf, buf + ninp, buf + einp);
setp(buf + einp, buf + new_size);
- pbump(static_cast<int>(nout));
+ __pbump(nout);
__strmode_ |= __allocated;
}
*pptr() = static_cast<char>(__c);
@@ -282,7 +282,7 @@
// min(pbase, newpos), newpos, epptr()
__off = epptr() - newpos;
setp(min(pbase(), newpos), epptr());
- pbump(static_cast<int>((epptr() - pbase()) - __off));
+ __pbump((epptr() - pbase()) - __off);
}
__p = newoff;
}
@@ -312,7 +312,7 @@
// min(pbase, newpos), newpos, epptr()
off_type temp = epptr() - newpos;
setp(min(pbase(), newpos), epptr());
- pbump(static_cast<int>((epptr() - pbase()) - temp));
+ __pbump((epptr() - pbase()) - temp);
}
__p = newoff;
}
diff --git a/src/support/runtime/exception_fallback.ipp b/src/support/runtime/exception_fallback.ipp
index 69c06a9..664e7f4 100644
--- a/src/support/runtime/exception_fallback.ipp
+++ b/src/support/runtime/exception_fallback.ipp
@@ -20,13 +20,13 @@
unexpected_handler
set_unexpected(unexpected_handler func) _NOEXCEPT
{
- return __sync_lock_test_and_set(&__unexpected_handler, func);
+ return __libcpp_atomic_exchange(&__unexpected_handler, func);
}
unexpected_handler
get_unexpected() _NOEXCEPT
{
- return __sync_fetch_and_add(&__unexpected_handler, (unexpected_handler)0);
+ return __libcpp_atomic_load(&__unexpected_handler);
}
@@ -41,14 +41,13 @@
terminate_handler
set_terminate(terminate_handler func) _NOEXCEPT
{
- return __sync_lock_test_and_set(&__terminate_handler, func);
+ return __libcpp_atomic_exchange(&__terminate_handler, func);
}
terminate_handler
get_terminate() _NOEXCEPT
{
- return __sync_fetch_and_add(&__terminate_handler, (terminate_handler)0);
-
+ return __libcpp_atomic_load(&__terminate_handler);
}
#ifndef __EMSCRIPTEN__ // We provide this in JS
diff --git a/src/support/runtime/exception_msvc.ipp b/src/support/runtime/exception_msvc.ipp
index 950ec0c..d5bf5b7 100644
--- a/src/support/runtime/exception_msvc.ipp
+++ b/src/support/runtime/exception_msvc.ipp
@@ -14,12 +14,35 @@
#include <stdio.h>
#include <stdlib.h>
-#include <eh.h>
-#include <corecrt_terminate.h>
+
+#if !defined(_ACRTIMP)
+#define _ACRTIMP __declspec(dllimport)
+#endif
+
+#if !defined(_VCRTIMP)
+#define _VCRTIMP __declspec(dllimport)
+#endif
+
+#if !defined(__CRTDECL)
+#define __CRTDECL __cdecl
+#endif
+
+extern "C" {
+typedef void (__CRTDECL* terminate_handler)();
+_ACRTIMP terminate_handler __cdecl set_terminate(
+ terminate_handler _NewTerminateHandler) throw();
+_ACRTIMP terminate_handler __cdecl _get_terminate();
+
+typedef void (__CRTDECL* unexpected_handler)();
+_VCRTIMP unexpected_handler __cdecl set_unexpected(
+ unexpected_handler _NewUnexpectedHandler) throw();
+_VCRTIMP unexpected_handler __cdecl _get_unexpected();
+
+_VCRTIMP int __cdecl __uncaught_exceptions();
+}
namespace std {
-// libcxxrt provides implementations of these functions itself.
unexpected_handler
set_unexpected(unexpected_handler func) _NOEXCEPT {
return ::set_unexpected(func);
@@ -86,4 +109,82 @@
return "bad_array_length";
}
+bad_cast::bad_cast() _NOEXCEPT
+{
+}
+
+bad_cast::~bad_cast() _NOEXCEPT
+{
+}
+
+const char *
+bad_cast::what() const _NOEXCEPT
+{
+ return "std::bad_cast";
+}
+
+bad_typeid::bad_typeid() _NOEXCEPT
+{
+}
+
+bad_typeid::~bad_typeid() _NOEXCEPT
+{
+}
+
+const char *
+bad_typeid::what() const _NOEXCEPT
+{
+ return "std::bad_typeid";
+}
+
+#if defined(_LIBCPP_NO_VCRUNTIME)
+exception::~exception() _NOEXCEPT
+{
+}
+
+const char* exception::what() const _NOEXCEPT
+{
+ return "std::exception";
+}
+
+
+bad_exception::~bad_exception() _NOEXCEPT
+{
+}
+
+const char* bad_exception::what() const _NOEXCEPT
+{
+ return "std::bad_exception";
+}
+
+
+bad_alloc::bad_alloc() _NOEXCEPT
+{
+}
+
+bad_alloc::~bad_alloc() _NOEXCEPT
+{
+}
+
+const char*
+bad_alloc::what() const _NOEXCEPT
+{
+ return "std::bad_alloc";
+}
+
+bad_array_new_length::bad_array_new_length() _NOEXCEPT
+{
+}
+
+bad_array_new_length::~bad_array_new_length() _NOEXCEPT
+{
+}
+
+const char*
+bad_array_new_length::what() const _NOEXCEPT
+{
+ return "bad_array_new_length";
+}
+#endif // _LIBCPP_NO_VCRUNTIME
+
} // namespace std
diff --git a/src/support/runtime/exception_pointer_msvc.ipp b/src/support/runtime/exception_pointer_msvc.ipp
index eab5d30..5ca7519 100644
--- a/src/support/runtime/exception_pointer_msvc.ipp
+++ b/src/support/runtime/exception_pointer_msvc.ipp
@@ -10,26 +10,32 @@
#include <stdio.h>
#include <stdlib.h>
-#include <yvals.h> // for _CRTIMP2_PURE
-_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrCreate(_Out_ void*);
-_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrDestroy(_Inout_ void*);
-_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrCopy(_Out_ void*,
- _In_ const void*);
+#if !defined(_CRTIMP2_PURE)
+#define _CRTIMP2_PURE __declspec(dllimport)
+#endif
+
+#if !defined(__CLRCALL_PURE_OR_CDECL)
+#define __CLRCALL_PURE_OR_CDECL __cdecl
+#endif
+
+_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrCreate(void*);
+_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrDestroy(void*);
+_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrCopy(void*,
+ const void*);
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL
-__ExceptionPtrAssign(_Inout_ void*, _In_ const void*);
+__ExceptionPtrAssign(void*, const void*);
_CRTIMP2_PURE bool __CLRCALL_PURE_OR_CDECL
-__ExceptionPtrCompare(_In_ const void*, _In_ const void*);
+__ExceptionPtrCompare(const void*, const void*);
_CRTIMP2_PURE bool __CLRCALL_PURE_OR_CDECL
-__ExceptionPtrToBool(_In_ const void*);
-_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrSwap(_Inout_ void*,
- _Inout_ void*);
+__ExceptionPtrToBool(const void*);
+_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrSwap(void*, void*);
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL
-__ExceptionPtrCurrentException(_Out_ void*);
+__ExceptionPtrCurrentException(void*);
[[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL
-__ExceptionPtrRethrow(_In_ const void*);
+__ExceptionPtrRethrow(const void*);
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL
-__ExceptionPtrCopyException(_Inout_ void*, _In_ const void*, _In_ const void*);
+__ExceptionPtrCopyException(void*, const void*, const void*);
namespace std {
diff --git a/src/support/runtime/new_handler_fallback.ipp b/src/support/runtime/new_handler_fallback.ipp
index b7092d5..ec3f523 100644
--- a/src/support/runtime/new_handler_fallback.ipp
+++ b/src/support/runtime/new_handler_fallback.ipp
@@ -15,13 +15,13 @@
new_handler
set_new_handler(new_handler handler) _NOEXCEPT
{
- return __sync_lock_test_and_set(&__new_handler, handler);
+ return __libcpp_atomic_exchange(&__new_handler, handler);
}
new_handler
get_new_handler() _NOEXCEPT
{
- return __sync_fetch_and_add(&__new_handler, nullptr);
+ return __libcpp_atomic_load(&__new_handler);
}
} // namespace std
diff --git a/src/system_error.cpp b/src/system_error.cpp
index 17f2c9a..72623ea 100644
--- a/src/system_error.cpp
+++ b/src/system_error.cpp
@@ -73,39 +73,59 @@
std::snprintf(buffer, strerror_buff_size, "unknown error %d", ev);
return string(buffer);
}
-#elif 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
+
+// Only one of the two following functions will be used, depending on
+// the return type of strerror_r:
+
+// For the GNU variant, a char* return value:
+__attribute__((unused)) const char *
+handle_strerror_r_return(char *strerror_return, char *buffer) {
+ // GNU always returns a string pointer in its return value. The
+ // string might point to either the input buffer, or a static
+ // buffer, but we don't care which.
+ return strerror_return;
+}
+
+// For the POSIX variant: an int return value.
+__attribute__((unused)) const char *
+handle_strerror_r_return(int strerror_return, char *buffer) {
+ // The POSIX variant either:
+ // - fills in the provided buffer and returns 0
+ // - returns a positive error value, or
+ // - returns -1 and fills in errno with an error value.
+ if (strerror_return == 0)
+ return buffer;
+
+ // Only handle EINVAL. Other errors abort.
+ int new_errno = strerror_return == -1 ? errno : strerror_return;
+ if (new_errno == EINVAL)
+ return "";
+
+ _LIBCPP_ASSERT(new_errno == ERANGE, "unexpected error from ::strerror_r");
+ // FIXME maybe? 'strerror_buff_size' is likely to exceed the
+ // maximum error size so ERANGE shouldn't be returned.
+ std::abort();
+}
+
+// This function handles both GNU and POSIX variants, dispatching to
+// one of the two above functions.
string do_strerror_r(int ev) {
char buffer[strerror_buff_size];
+ // Preserve errno around the call. (The C++ standard requires that
+ // system_error functions not modify errno).
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 {
- _LIBCPP_ASSERT(new_errno == ERANGE, "unexpected error from ::strerr_r");
- // FIXME maybe? 'strerror_buff_size' is likely to exceed the
- // maximum error size so ERANGE shouldn't be returned.
- std::abort();
- }
+ const char *error_message = handle_strerror_r_return(
+ ::strerror_r(ev, buffer, strerror_buff_size), buffer);
+ // If we didn't get any message, print one now.
+ if (!error_message[0]) {
+ std::snprintf(buffer, strerror_buff_size, "Unknown error %d", ev);
+ error_message = buffer;
}
- return string(buffer);
+ errno = old_errno;
+ return string(error_message);
}
#endif
-
} // end namespace
#endif
diff --git a/src/typeinfo.cpp b/src/typeinfo.cpp
index 02778f3..0cb193b 100644
--- a/src/typeinfo.cpp
+++ b/src/typeinfo.cpp
@@ -9,11 +9,48 @@
#include "typeinfo"
+#if defined(_LIBCPP_ABI_MICROSOFT)
+#include <string.h>
+
+int std::type_info::__compare(const type_info &__rhs) const _NOEXCEPT {
+ if (&__data == &__rhs.__data)
+ return 0;
+ return strcmp(&__data.__decorated_name[1], &__rhs.__data.__decorated_name[1]);
+}
+
+const char *std::type_info::name() const _NOEXCEPT {
+ // TODO(compnerd) cache demangled &__data.__decorated_name[1]
+ return &__data.__decorated_name[1];
+}
+
+size_t std::type_info::hash_code() const _NOEXCEPT {
+#if defined(_WIN64)
+ constexpr size_t fnv_offset_basis = 14695981039346656037ull;
+ constexpr size_t fnv_prime = 10995116282110ull;
+#else
+ constexpr size_t fnv_offset_basis = 2166136261ull;
+ constexpr size_t fnv_prime = 16777619ull;
+#endif
+
+ size_t value = fnv_offset_basis;
+ for (const char* c = &__data.__decorated_name[1]; *c; ++c) {
+ value ^= static_cast<size_t>(static_cast<unsigned char>(*c));
+ value *= fnv_prime;
+ }
+
+#if defined(_WIN64)
+ value ^= value >> 32;
+#endif
+
+ return value;
+}
+#endif // _LIBCPP_ABI_MICROSOFT
+
// FIXME: Remove __APPLE__ default here once buildit is gone.
-#if (!defined(_LIBCPP_ABI_MICROSOFT) && !defined(LIBCXX_BUILDING_LIBCXXABI) && \
- !defined(LIBCXXRT) && !defined(__GLIBCXX__) && \
- !defined(__APPLE__)) || \
- defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY) // FIXME: remove this configuration.
+// FIXME: Remove the _LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY configuration.
+#if (!defined(LIBCXX_BUILDING_LIBCXXABI) && !defined(LIBCXXRT) && \
+ !defined(__GLIBCXX__) && !defined(__APPLE__)) || \
+ defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY)
std::type_info::~type_info()
{
}
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 6f2eac0..4c8ca8f 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -49,10 +49,9 @@
set(AUTO_GEN_COMMENT "## Autogenerated by libcxx configuration.\n# Do not edit!")
-configure_file(
+configure_lit_site_cfg(
${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
- ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg
- @ONLY)
+ ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg)
set(LIBCXX_TEST_DEPS "")
@@ -85,3 +84,36 @@
set(extract_dirs "${LIBCXX_SOURCE_DIR}/include;${LIBCXX_SOURCE_DIR}/src")
setup_lcov_test_target_coverage("cxx" "${output_dir}" "${capture_dirs}" "${extract_dirs}")
endif()
+
+
+if (LIBCXX_CONFIGURE_IDE)
+ # Create dummy targets for each of the tests in the test suite, this allows
+ # IDE's such as CLion to correctly highlight the tests because it knows
+ # roughly what include paths/compile flags/macro definitions are needed.
+ include_directories(support)
+ file(GLOB_RECURSE LIBCXX_TESTS ${CMAKE_CURRENT_SOURCE_DIR}/*.pass.cpp)
+ file(GLOB LIBCXX_TEST_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/support/*)
+ file(GLOB_RECURSE LIBCXX_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/../include/*)
+ add_executable(libcxx_test_objects EXCLUDE_FROM_ALL
+ ${LIBCXX_TESTS} ${LIBCXX_TEST_HEADERS} ${LIBCXX_HEADERS})
+ add_dependencies(libcxx_test_objects cxx)
+
+ set(STATIC_ROOT ${LIBCXX_SOURCE_DIR}/test/std/experimental/filesystem/Inputs/static_test_env)
+ add_definitions(-DLIBCXX_FILESYSTEM_STATIC_TEST_ROOT="${STATIC_ROOT}")
+
+ set(DYNAMIC_ROOT ${LIBCXX_BINARY_DIR}/test/filesystem/Output/dynamic_env)
+ add_definitions(-DLIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT="${DYNAMIC_ROOT}")
+
+ set(DYNAMIC_HELPER "python ${LIBCXX_SOURCE_DIR}/test/support/filesystem_dynamic_test_helper.py ")
+ add_definitions(-DLIBCXX_FILESYSTEM_DYNAMIC_TEST_HELPER="${DYNAMIC_HELPER}")
+
+ split_list(LIBCXX_COMPILE_FLAGS)
+ split_list(LIBCXX_LINK_FLAGS)
+
+ set_target_properties(libcxx_test_objects
+ PROPERTIES
+ COMPILE_FLAGS "${LIBCXX_COMPILE_FLAGS}"
+ LINK_FLAGS "${LIBCXX_LINK_FLAGS}"
+ EXCLUDE_FROM_ALL ON
+ )
+endif()
diff --git a/test/libcxx/algorithms/debug_less.pass.cpp b/test/libcxx/algorithms/debug_less.pass.cpp
index 2e875ff..e030f64 100644
--- a/test/libcxx/algorithms/debug_less.pass.cpp
+++ b/test/libcxx/algorithms/debug_less.pass.cpp
@@ -164,4 +164,4 @@
int main() {
test_passing();
test_failing();
-}
\ No newline at end of file
+}
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
index 589af7c..6e25b0c 100644
--- 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
@@ -27,4 +27,4 @@
std::list<int> v2(3);
v1.insert(v2.begin(), 4);
assert(false);
-}
\ No newline at end of file
+}
diff --git a/test/libcxx/containers/unord/next_pow2.pass.cpp b/test/libcxx/containers/unord/next_pow2.pass.cpp
index 3784eb8..a878da4 100644
--- a/test/libcxx/containers/unord/next_pow2.pass.cpp
+++ b/test/libcxx/containers/unord/next_pow2.pass.cpp
@@ -54,12 +54,12 @@
assert(std::__next_hash_pow2(pow2) == pow2);
}
- test_next_pow2_val(3);
- test_next_pow2_val(7);
- test_next_pow2_val(9);
- test_next_pow2_val(15);
- test_next_pow2_val(127);
- test_next_pow2_val(129);
+ test_next_pow2_val(3);
+ test_next_pow2_val(7);
+ test_next_pow2_val(9);
+ test_next_pow2_val(15);
+ test_next_pow2_val(127);
+ test_next_pow2_val(129);
}
// Note: this is only really useful when run with -fsanitize=undefined.
diff --git a/test/libcxx/depr/depr.c.headers/complex.h.pass.cpp b/test/libcxx/depr/depr.c.headers/complex.h.pass.cpp
index da07079..7abe8e0 100644
--- a/test/libcxx/depr/depr.c.headers/complex.h.pass.cpp
+++ b/test/libcxx/depr/depr.c.headers/complex.h.pass.cpp
@@ -18,4 +18,5 @@
int main()
{
std::complex<double> d;
+ (void)d;
}
diff --git a/test/libcxx/depr/depr.c.headers/tgmath_h.pass.cpp b/test/libcxx/depr/depr.c.headers/tgmath_h.pass.cpp
index a2ef814..931e3a3 100644
--- a/test/libcxx/depr/depr.c.headers/tgmath_h.pass.cpp
+++ b/test/libcxx/depr/depr.c.headers/tgmath_h.pass.cpp
@@ -18,6 +18,7 @@
int main()
{
std::complex<double> cd;
+ (void)cd;
double x = sin(1.0);
(void)x; // to placate scan-build
}
diff --git a/test/libcxx/depr/depr.function.objects/depr.adaptors.cxx1z.pass.cpp b/test/libcxx/depr/depr.function.objects/depr.adaptors.cxx1z.pass.cpp
index f06dbb9..1847dac 100644
--- a/test/libcxx/depr/depr.function.objects/depr.adaptors.cxx1z.pass.cpp
+++ b/test/libcxx/depr/depr.function.objects/depr.adaptors.cxx1z.pass.cpp
@@ -24,25 +24,25 @@
int sum(int a, int b) { return a + b; }
struct Foo {
- int zero() const { return 0; }
- int identity(int v) const { return v; }
- int sum(int a, int b) const { return a + b; }
+ int zero() const { return 0; }
+ int identity(int v) const { return v; }
+ int sum(int a, int b) const { return a + b; }
};
int main()
{
- typedef std::pointer_to_unary_function<int, int> PUF;
- typedef std::pointer_to_binary_function<int, int, int> PBF;
- assert((std::ptr_fun<int, int>(identity)(4) == 4));
- assert((std::ptr_fun<int, int, int>(sum)(4, 5) == 9));
+ typedef std::pointer_to_unary_function<int, int> PUF;
+ typedef std::pointer_to_binary_function<int, int, int> PBF;
+ assert((std::ptr_fun<int, int>(identity)(4) == 4));
+ assert((std::ptr_fun<int, int, int>(sum)(4, 5) == 9));
- Foo f;
- assert((std::mem_fn(&Foo::identity)(f, 5) == 5));
- assert((std::mem_fn(&Foo::sum)(f, 5, 6) == 11));
+ Foo f;
+ assert((std::mem_fn(&Foo::identity)(f, 5) == 5));
+ assert((std::mem_fn(&Foo::sum)(f, 5, 6) == 11));
typedef std::mem_fun_ref_t<int, Foo> MFR;
typedef std::const_mem_fun_ref_t<int, Foo> CMFR;
- assert((std::mem_fun_ref(&Foo::zero)(f) == 0));
- assert((std::mem_fun_ref(&Foo::identity)(f, 5) == 5));
+ assert((std::mem_fun_ref(&Foo::zero)(f) == 0));
+ assert((std::mem_fun_ref(&Foo::identity)(f, 5) == 5));
}
diff --git a/test/libcxx/experimental/containers/sequences/dynarray/dynarray.cons/default_throws_bad_alloc.pass.cpp b/test/libcxx/experimental/containers/sequences/dynarray/dynarray.cons/default_throws_bad_alloc.pass.cpp
index 9c6cad8..4009841 100644
--- a/test/libcxx/experimental/containers/sequences/dynarray/dynarray.cons/default_throws_bad_alloc.pass.cpp
+++ b/test/libcxx/experimental/containers/sequences/dynarray/dynarray.cons/default_throws_bad_alloc.pass.cpp
@@ -16,7 +16,7 @@
// UNSUPPORTED: c++98, c++03, c++11
// The sanitizers replace new/delete with versions that do not throw bad_alloc.
-// UNSUPPORTED: sanitizer-new-delete, ubsan
+// UNSUPPORTED: sanitizer-new-delete
#include <experimental/dynarray>
diff --git a/test/libcxx/experimental/filesystem/class.path/path.itr/iterator_db.pass.cpp b/test/libcxx/experimental/filesystem/class.path/path.itr/iterator_db.pass.cpp
index a98a9cc..aea46f1 100644
--- a/test/libcxx/experimental/filesystem/class.path/path.itr/iterator_db.pass.cpp
+++ b/test/libcxx/experimental/filesystem/class.path/path.itr/iterator_db.pass.cpp
@@ -71,4 +71,4 @@
assert(false);
} catch (int) {}
}
-}
\ No newline at end of file
+}
diff --git a/test/libcxx/experimental/filesystem/class.path/path.itr/reverse_iterator_produces_diagnostic.fail.cpp b/test/libcxx/experimental/filesystem/class.path/path.itr/reverse_iterator_produces_diagnostic.fail.cpp
index 6f839be..5a6f530 100644
--- a/test/libcxx/experimental/filesystem/class.path/path.itr/reverse_iterator_produces_diagnostic.fail.cpp
+++ b/test/libcxx/experimental/filesystem/class.path/path.itr/reverse_iterator_produces_diagnostic.fail.cpp
@@ -23,7 +23,7 @@
using namespace fs;
using RIt = std::reverse_iterator<path::iterator>;
- // expected-error@iterator:* {{static_assert failed "The specified iterator type cannot be used with reverse_iterator; Using stashing iterators with reverse_iterator causes undefined behavior"}}
+ // expected-error-re@iterator:* {{static_assert failed{{.*}} "The specified iterator type cannot be used with reverse_iterator; Using stashing iterators with reverse_iterator causes undefined behavior"}}
{
RIt r;
((void)r);
diff --git a/test/libcxx/experimental/filesystem/convert_file_time.sh.cpp b/test/libcxx/experimental/filesystem/convert_file_time.sh.cpp
new file mode 100644
index 0000000..972d518
--- /dev/null
+++ b/test/libcxx/experimental/filesystem/convert_file_time.sh.cpp
@@ -0,0 +1,200 @@
+//===----------------------------------------------------------------------===//
+//
+// The 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/filesystem>
+
+// typedef TrivialClock file_time_type;
+
+// RUN: %build -I%libcxx_src_root/src/experimental/filesystem
+// RUN: %run
+
+#include <experimental/filesystem>
+#include <chrono>
+#include <type_traits>
+#include <limits>
+#include <cstddef>
+#include <cassert>
+
+#include "filesystem_time_helper.h"
+
+using namespace std::chrono;
+namespace fs = std::experimental::filesystem;
+using fs::file_time_type;
+using fs::fs_time_util;
+
+enum TestKind { TK_64Bit, TK_32Bit, TK_FloatingPoint };
+
+template <class FileTimeT, class TimeT, class TimeSpec>
+constexpr TestKind getTestKind() {
+ if (sizeof(TimeT) == 8 && !std::is_floating_point<TimeT>::value)
+ return TK_64Bit;
+ else if (sizeof(TimeT) == 4 && !std::is_floating_point<TimeT>::value)
+ return TK_32Bit;
+ else if (std::is_floating_point<TimeT>::value)
+ return TK_FloatingPoint;
+ else
+ assert(false && "test kind not supported");
+}
+
+template <class FileTimeT, class TimeT, class TimeSpecT,
+ class Base = fs_time_util<FileTimeT, TimeT, TimeSpecT>,
+ TestKind = getTestKind<FileTimeT, TimeT, TimeSpecT>()>
+struct check_is_representable;
+
+template <class FileTimeT, class TimeT, class TimeSpecT, class Base>
+struct check_is_representable<FileTimeT, TimeT, TimeSpecT, Base, TK_64Bit>
+ : public Base {
+
+ using Base::convert_timespec;
+ using Base::is_representable;
+ using Base::max_nsec;
+ using Base::max_seconds;
+ using Base::min_nsec_timespec;
+ using Base::min_seconds;
+
+ static constexpr auto max_time_t = std::numeric_limits<TimeT>::max();
+ static constexpr auto min_time_t = std::numeric_limits<TimeT>::min();
+
+ static constexpr bool test_timespec() {
+ static_assert(is_representable(TimeSpecT{max_seconds, max_nsec}), "");
+ static_assert(!is_representable(TimeSpecT{max_seconds + 1, 0}), "");
+ static_assert(!is_representable(TimeSpecT{max_seconds, max_nsec + 1}), "");
+ static_assert(!is_representable(TimeSpecT{max_time_t, 0}), "");
+ static_assert(is_representable(TimeSpecT{min_seconds, 0}), "");
+ static_assert(
+ is_representable(TimeSpecT{min_seconds - 1, min_nsec_timespec}), "");
+ static_assert(
+ is_representable(TimeSpecT{min_seconds - 1, min_nsec_timespec + 1}),
+ "");
+ static_assert(
+ !is_representable(TimeSpecT{min_seconds - 1, min_nsec_timespec - 1}),
+ "");
+ static_assert(!is_representable(TimeSpecT{min_time_t, 999999999}), "");
+ return true;
+ }
+
+ static constexpr bool test_file_time_type() {
+ static_assert(Base::is_representable(FileTimeT::max()), "");
+ static_assert(Base::is_representable(FileTimeT::min()), "");
+ return true;
+ }
+
+ static constexpr bool test_convert_timespec() {
+ static_assert(convert_timespec(TimeSpecT{max_seconds, max_nsec}) ==
+ FileTimeT::max(),
+ "");
+ static_assert(convert_timespec(TimeSpecT{max_seconds, max_nsec - 1}) <
+ FileTimeT::max(),
+ "");
+ static_assert(convert_timespec(TimeSpecT{max_seconds - 1, 999999999}) <
+ FileTimeT::max(),
+ "");
+ static_assert(convert_timespec(TimeSpecT{
+ min_seconds - 1, min_nsec_timespec}) == FileTimeT::min(),
+ "");
+ static_assert(
+ convert_timespec(TimeSpecT{min_seconds - 1, min_nsec_timespec + 1}) >
+ FileTimeT::min(),
+ "");
+ static_assert(
+ convert_timespec(TimeSpecT{min_seconds, 0}) > FileTimeT::min(), "");
+ return true;
+ }
+
+ static bool test() {
+ static_assert(test_timespec(), "");
+ static_assert(test_file_time_type(), "");
+ static_assert(test_convert_timespec(), "");
+ return true;
+ }
+};
+
+template <class FileTimeT, class TimeT, class TimeSpecT, class Base>
+struct check_is_representable<FileTimeT, TimeT, TimeSpecT, Base, TK_32Bit>
+ : public Base {
+ static constexpr auto max_time_t = std::numeric_limits<TimeT>::max();
+ static constexpr auto min_time_t = std::numeric_limits<TimeT>::min();
+
+ using Base::convert_timespec;
+ using Base::is_representable;
+ using Base::max_nsec;
+ using Base::max_seconds;
+ using Base::min_nsec_timespec;
+ using Base::min_seconds;
+
+ static constexpr bool test_timespec() {
+ static_assert(is_representable(TimeSpecT{max_time_t, 999999999}), "");
+ static_assert(is_representable(TimeSpecT{max_time_t, 1000000000}), "");
+ static_assert(is_representable(TimeSpecT{min_time_t, 0}), "");
+ return true;
+ }
+
+ static constexpr bool test_file_time_type() {
+ static_assert(!is_representable(FileTimeT::max()), "");
+ static_assert(!is_representable(FileTimeT::min()), "");
+ static_assert(is_representable(FileTimeT(seconds(max_time_t))), "");
+ static_assert(is_representable(FileTimeT(seconds(min_time_t))), "");
+ return true;
+ }
+
+ static constexpr bool test_convert_timespec() {
+ // FIXME add tests for 32 bit builds
+ return true;
+ }
+
+ static bool test() {
+ static_assert(test_timespec(), "");
+ static_assert(test_file_time_type(), "");
+ static_assert(test_convert_timespec(), "");
+ return true;
+ }
+};
+
+template <class FileTimeT, class TimeT, class TimeSpec, class Base>
+struct check_is_representable<FileTimeT, TimeT, TimeSpec, Base,
+ TK_FloatingPoint> : public Base {
+
+ static bool test() { return true; }
+};
+
+template <class TimeT, class NSecT = long>
+struct TestTimeSpec {
+ TimeT tv_sec;
+ NSecT tv_nsec;
+};
+
+template <class Dur>
+struct TestClock {
+ typedef Dur duration;
+ typedef typename duration::rep rep;
+ typedef typename duration::period period;
+ typedef std::chrono::time_point<TestClock> time_point;
+ static constexpr const bool is_steady = false;
+
+ static time_point now() noexcept { return {}; }
+};
+
+template <class IntType, class Dur = duration<IntType, std::micro> >
+using TestFileTimeT = time_point<TestClock<Dur> >;
+
+int main() {
+ assert((
+ check_is_representable<file_time_type, time_t, struct timespec>::test()));
+ assert((check_is_representable<TestFileTimeT<int64_t>, int64_t,
+ TestTimeSpec<int64_t, long> >::test()));
+ assert((check_is_representable<TestFileTimeT<long long>, int32_t,
+ TestTimeSpec<int32_t, int32_t> >::test()));
+
+ // Test that insane platforms like ppc64 linux, which use long double as time_t,
+ // at least compile.
+ assert((check_is_representable<TestFileTimeT<long double>, double,
+ TestTimeSpec<long double, long> >::test()));
+}
diff --git a/test/libcxx/fuzzing/nth_element.cpp b/test/libcxx/fuzzing/nth_element.cpp
new file mode 100644
index 0000000..ee7f0d8
--- /dev/null
+++ b/test/libcxx/fuzzing/nth_element.cpp
@@ -0,0 +1,38 @@
+// -*- C++ -*-
+//===----------------------- nth_element.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.
+//
+//===----------------------------------------------------------------------===//
+
+// XFAIL
+
+#include "fuzzing.h"
+#include <cassert>
+#include <cstring> // for strlen
+
+const char * test_cases[] = {
+ "",
+ "s",
+ "bac",
+ "bacasf"
+ "lkajseravea",
+ "adsfkajdsfjkas;lnc441324513,34535r34525234"
+ };
+
+const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
+
+
+int main ()
+{
+ for (size_t i = 0; i < k_num_tests; ++i)
+ {
+ const size_t size = std::strlen(test_cases[i]);
+ const uint8_t *data = (const uint8_t *) test_cases[i];
+ assert(0 == fuzzing::nth_element(data, size));
+ }
+ return 0;
+}
diff --git a/test/libcxx/fuzzing/partial_sort.cpp b/test/libcxx/fuzzing/partial_sort.cpp
new file mode 100644
index 0000000..0c5889d
--- /dev/null
+++ b/test/libcxx/fuzzing/partial_sort.cpp
@@ -0,0 +1,38 @@
+// -*- C++ -*-
+//===-------------------------- partial_sort.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.
+//
+//===----------------------------------------------------------------------===//
+
+// XFAIL
+
+#include "fuzzing.h"
+#include <cassert>
+#include <cstring> // for strlen
+
+const char * test_cases[] = {
+ "",
+ "s",
+ "bac",
+ "bacasf"
+ "lkajseravea",
+ "adsfkajdsfjkas;lnc441324513,34535r34525234"
+ };
+
+const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
+
+
+int main ()
+{
+ for (size_t i = 0; i < k_num_tests; ++i)
+ {
+ const size_t size = std::strlen(test_cases[i]);
+ const uint8_t *data = (const uint8_t *) test_cases[i];
+ assert(0 == fuzzing::partial_sort(data, size));
+ }
+ return 0;
+}
diff --git a/test/libcxx/fuzzing/partition.cpp b/test/libcxx/fuzzing/partition.cpp
new file mode 100644
index 0000000..03eed8c
--- /dev/null
+++ b/test/libcxx/fuzzing/partition.cpp
@@ -0,0 +1,38 @@
+// -*- C++ -*-
+//===--------------------------- partition.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.
+//
+//===----------------------------------------------------------------------===//
+
+// XFAIL
+
+#include "fuzzing.h"
+#include <cassert>
+#include <cstring> // for strlen
+
+const char * test_cases[] = {
+ "",
+ "s",
+ "bac",
+ "bacasf"
+ "lkajseravea",
+ "adsfkajdsfjkas;lnc441324513,34535r34525234"
+ };
+
+const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
+
+
+int main ()
+{
+ for (size_t i = 0; i < k_num_tests; ++i)
+ {
+ const size_t size = std::strlen(test_cases[i]);
+ const uint8_t *data = (const uint8_t *) test_cases[i];
+ assert(0 == fuzzing::partition(data, size));
+ }
+ return 0;
+}
diff --git a/test/libcxx/fuzzing/regex_ECMAScript.cpp b/test/libcxx/fuzzing/regex_ECMAScript.cpp
new file mode 100644
index 0000000..2e57126
--- /dev/null
+++ b/test/libcxx/fuzzing/regex_ECMAScript.cpp
@@ -0,0 +1,37 @@
+// -*- C++ -*-
+//===--------------------- regex_ECMAScript.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.
+//
+//===----------------------------------------------------------------------===//
+
+// XFAIL
+
+#include "fuzzing.h"
+#include <cassert>
+#include <cstring> // for strlen
+
+const char * test_cases[] = {
+ "",
+ "s",
+ "b*c",
+ "ba?sf"
+ "lka*ea",
+ "adsf*kas;lnc441[0-9]1r34525234"
+ };
+
+const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
+
+int main ()
+{
+ for (size_t i = 0; i < k_num_tests; ++i)
+ {
+ const size_t size = std::strlen(test_cases[i]);
+ const uint8_t *data = (const uint8_t *) test_cases[i];
+ assert(0 == fuzzing::regex_ECMAScript(data, size));
+ }
+ return 0;
+}
diff --git a/test/libcxx/fuzzing/regex_POSIX.cpp b/test/libcxx/fuzzing/regex_POSIX.cpp
new file mode 100644
index 0000000..f0bd289
--- /dev/null
+++ b/test/libcxx/fuzzing/regex_POSIX.cpp
@@ -0,0 +1,37 @@
+// -*- C++ -*-
+//===----------------------- regex_POSIX.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.
+//
+//===----------------------------------------------------------------------===//
+
+// XFAIL
+
+#include "fuzzing.h"
+#include <cassert>
+#include <cstring> // for strlen
+
+const char * test_cases[] = {
+ "",
+ "s",
+ "b*c",
+ "ba?sf"
+ "lka*ea",
+ "adsf*kas;lnc441[0-9]1r34525234"
+ };
+
+const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
+
+int main ()
+{
+ for (size_t i = 0; i < k_num_tests; ++i)
+ {
+ const size_t size = std::strlen(test_cases[i]);
+ const uint8_t *data = (const uint8_t *) test_cases[i];
+ assert(0 == fuzzing::regex_POSIX(data, size));
+ }
+ return 0;
+}
diff --git a/test/libcxx/fuzzing/regex_awk.cpp b/test/libcxx/fuzzing/regex_awk.cpp
new file mode 100644
index 0000000..2e57126
--- /dev/null
+++ b/test/libcxx/fuzzing/regex_awk.cpp
@@ -0,0 +1,37 @@
+// -*- C++ -*-
+//===--------------------- regex_ECMAScript.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.
+//
+//===----------------------------------------------------------------------===//
+
+// XFAIL
+
+#include "fuzzing.h"
+#include <cassert>
+#include <cstring> // for strlen
+
+const char * test_cases[] = {
+ "",
+ "s",
+ "b*c",
+ "ba?sf"
+ "lka*ea",
+ "adsf*kas;lnc441[0-9]1r34525234"
+ };
+
+const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
+
+int main ()
+{
+ for (size_t i = 0; i < k_num_tests; ++i)
+ {
+ const size_t size = std::strlen(test_cases[i]);
+ const uint8_t *data = (const uint8_t *) test_cases[i];
+ assert(0 == fuzzing::regex_ECMAScript(data, size));
+ }
+ return 0;
+}
diff --git a/test/libcxx/fuzzing/regex_egrep.cpp b/test/libcxx/fuzzing/regex_egrep.cpp
new file mode 100644
index 0000000..056869f
--- /dev/null
+++ b/test/libcxx/fuzzing/regex_egrep.cpp
@@ -0,0 +1,37 @@
+// -*- C++ -*-
+//===------------------------ regex_egrep.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.
+//
+//===----------------------------------------------------------------------===//
+
+// XFAIL
+
+#include "fuzzing.h"
+#include <cassert>
+#include <cstring> // for strlen
+
+const char * test_cases[] = {
+ "",
+ "s",
+ "b*c",
+ "ba?sf"
+ "lka*ea",
+ "adsf*kas;lnc441[0-9]1r34525234"
+ };
+
+const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
+
+int main ()
+{
+ for (size_t i = 0; i < k_num_tests; ++i)
+ {
+ const size_t size = std::strlen(test_cases[i]);
+ const uint8_t *data = (const uint8_t *) test_cases[i];
+ assert(0 == fuzzing::regex_egrep(data, size));
+ }
+ return 0;
+}
diff --git a/test/libcxx/fuzzing/regex_extended.cpp b/test/libcxx/fuzzing/regex_extended.cpp
new file mode 100644
index 0000000..ac850eb
--- /dev/null
+++ b/test/libcxx/fuzzing/regex_extended.cpp
@@ -0,0 +1,37 @@
+// -*- C++ -*-
+//===---------------------- regex_extended.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.
+//
+//===----------------------------------------------------------------------===//
+
+// XFAIL
+
+#include "fuzzing.h"
+#include <cassert>
+#include <cstring> // for strlen
+
+const char * test_cases[] = {
+ "",
+ "s",
+ "b*c",
+ "ba?sf"
+ "lka*ea",
+ "adsf*kas;lnc441[0-9]1r34525234"
+ };
+
+const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
+
+int main ()
+{
+ for (size_t i = 0; i < k_num_tests; ++i)
+ {
+ const size_t size = std::strlen(test_cases[i]);
+ const uint8_t *data = (const uint8_t *) test_cases[i];
+ assert(0 == fuzzing::regex_extended(data, size));
+ }
+ return 0;
+}
diff --git a/test/libcxx/fuzzing/regex_grep.cpp b/test/libcxx/fuzzing/regex_grep.cpp
new file mode 100644
index 0000000..5b1dda2
--- /dev/null
+++ b/test/libcxx/fuzzing/regex_grep.cpp
@@ -0,0 +1,37 @@
+// -*- C++ -*-
+//===------------------------ regex_grep.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.
+//
+//===----------------------------------------------------------------------===//
+
+// XFAIL
+
+#include "fuzzing.h"
+#include <cassert>
+#include <cstring> // for strlen
+
+const char * test_cases[] = {
+ "",
+ "s",
+ "b*c",
+ "ba?sf"
+ "lka*ea",
+ "adsf*kas;lnc441[0-9]1r34525234"
+ };
+
+const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
+
+int main ()
+{
+ for (size_t i = 0; i < k_num_tests; ++i)
+ {
+ const size_t size = std::strlen(test_cases[i]);
+ const uint8_t *data = (const uint8_t *) test_cases[i];
+ assert(0 == fuzzing::regex_grep(data, size));
+ }
+ return 0;
+}
diff --git a/test/libcxx/fuzzing/sort.cpp b/test/libcxx/fuzzing/sort.cpp
new file mode 100644
index 0000000..4c46894
--- /dev/null
+++ b/test/libcxx/fuzzing/sort.cpp
@@ -0,0 +1,38 @@
+// -*- C++ -*-
+//===--------------------------- sort.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.
+//
+//===----------------------------------------------------------------------===//
+
+// XFAIL
+
+#include "fuzzing.h"
+#include <cassert>
+#include <cstring> // for strlen
+
+const char * test_cases[] = {
+ "",
+ "s",
+ "bac",
+ "bacasf"
+ "lkajseravea",
+ "adsfkajdsfjkas;lnc441324513,34535r34525234"
+ };
+
+const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
+
+
+int main ()
+{
+ for (size_t i = 0; i < k_num_tests; ++i)
+ {
+ const size_t size = std::strlen(test_cases[i]);
+ const uint8_t *data = (const uint8_t *) test_cases[i];
+ assert(0 == fuzzing::sort(data, size));
+ }
+ return 0;
+}
diff --git a/test/libcxx/fuzzing/stable_partition.cpp b/test/libcxx/fuzzing/stable_partition.cpp
new file mode 100644
index 0000000..c21e648
--- /dev/null
+++ b/test/libcxx/fuzzing/stable_partition.cpp
@@ -0,0 +1,38 @@
+// -*- C++ -*-
+//===--------------------- stable_partition.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.
+//
+//===----------------------------------------------------------------------===//
+
+// XFAIL
+
+#include "fuzzing.h"
+#include <cassert>
+#include <cstring> // for strlen
+
+const char * test_cases[] = {
+ "",
+ "s",
+ "bac",
+ "bacasf"
+ "lkajseravea",
+ "adsfkajdsfjkas;lnc441324513,34535r34525234"
+ };
+
+const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
+
+
+int main ()
+{
+ for (size_t i = 0; i < k_num_tests; ++i)
+ {
+ const size_t size = std::strlen(test_cases[i]);
+ const uint8_t *data = (const uint8_t *) test_cases[i];
+ assert(0 == fuzzing::stable_partition(data, size));
+ }
+ return 0;
+}
diff --git a/test/libcxx/fuzzing/stable_sort.cpp b/test/libcxx/fuzzing/stable_sort.cpp
new file mode 100644
index 0000000..1a7bbb9
--- /dev/null
+++ b/test/libcxx/fuzzing/stable_sort.cpp
@@ -0,0 +1,38 @@
+// -*- C++ -*-
+//===------------------------ stable_sort.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.
+//
+//===----------------------------------------------------------------------===//
+
+// XFAIL
+
+#include "fuzzing.h"
+#include <cassert>
+#include <cstring> // for strlen
+
+const char * test_cases[] = {
+ "",
+ "s",
+ "bac",
+ "bacasf"
+ "lkajseravea",
+ "adsfkajdsfjkas;lnc441324513,34535r34525234"
+ };
+
+const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
+
+
+int main ()
+{
+ for (size_t i = 0; i < k_num_tests; ++i)
+ {
+ const size_t size = std::strlen(test_cases[i]);
+ const uint8_t *data = (const uint8_t *) test_cases[i];
+ assert(0 == fuzzing::stable_sort(data, size));
+ }
+ return 0;
+}
diff --git a/test/libcxx/iterators/trivial_iterators.pass.cpp b/test/libcxx/iterators/trivial_iterators.pass.cpp
index fa3ebf2..f30c131 100644
--- a/test/libcxx/iterators/trivial_iterators.pass.cpp
+++ b/test/libcxx/iterators/trivial_iterators.pass.cpp
@@ -126,42 +126,42 @@
static_assert((!std::__libcpp_is_trivial_iterator<NonThrowingIterator <char *> >::value), "");
-// Iterator classification
- static_assert(( std::__is_input_iterator <char *>::value), "" );
- static_assert(( std::__is_forward_iterator <char *>::value), "" );
- static_assert(( std::__is_bidirectional_iterator<char *>::value), "" );
- static_assert(( std::__is_random_access_iterator<char *>::value), "" );
- static_assert((!std::__is_exactly_input_iterator<char *>::value), "" );
+// Iterator classification
+ static_assert(( std::__is_input_iterator <char *>::value), "" );
+ static_assert(( std::__is_forward_iterator <char *>::value), "" );
+ static_assert(( std::__is_bidirectional_iterator<char *>::value), "" );
+ static_assert(( std::__is_random_access_iterator<char *>::value), "" );
+ static_assert((!std::__is_exactly_input_iterator<char *>::value), "" );
- static_assert(( std::__is_input_iterator <input_iterator<char *> >::value), "" );
- static_assert((!std::__is_forward_iterator <input_iterator<char *> >::value), "" );
- 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 <input_iterator<char *> >::value), "" );
+ static_assert((!std::__is_forward_iterator <input_iterator<char *> >::value), "" );
+ 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), "" );
- static_assert((!std::__is_random_access_iterator<forward_iterator<char *> >::value), "" );
- static_assert((!std::__is_exactly_input_iterator<forward_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), "" );
+ static_assert((!std::__is_random_access_iterator<forward_iterator<char *> >::value), "" );
+ static_assert((!std::__is_exactly_input_iterator<forward_iterator<char *> >::value), "" );
- static_assert(( std::__is_input_iterator <bidirectional_iterator<char *> >::value), "" );
- static_assert(( std::__is_forward_iterator <bidirectional_iterator<char *> >::value), "" );
- static_assert(( std::__is_bidirectional_iterator<bidirectional_iterator<char *> >::value), "" );
- static_assert((!std::__is_random_access_iterator<bidirectional_iterator<char *> >::value), "" );
- static_assert((!std::__is_exactly_input_iterator<bidirectional_iterator<char *> >::value), "" );
+ static_assert(( std::__is_input_iterator <bidirectional_iterator<char *> >::value), "" );
+ static_assert(( std::__is_forward_iterator <bidirectional_iterator<char *> >::value), "" );
+ static_assert(( std::__is_bidirectional_iterator<bidirectional_iterator<char *> >::value), "" );
+ static_assert((!std::__is_random_access_iterator<bidirectional_iterator<char *> >::value), "" );
+ static_assert((!std::__is_exactly_input_iterator<bidirectional_iterator<char *> >::value), "" );
- static_assert(( std::__is_input_iterator <random_access_iterator<char *> >::value), "" );
- static_assert(( std::__is_forward_iterator <random_access_iterator<char *> >::value), "" );
- static_assert(( std::__is_bidirectional_iterator<random_access_iterator<char *> >::value), "" );
- static_assert(( std::__is_random_access_iterator<random_access_iterator<char *> >::value), "" );
- static_assert((!std::__is_exactly_input_iterator<random_access_iterator<char *> >::value), "" );
+ static_assert(( std::__is_input_iterator <random_access_iterator<char *> >::value), "" );
+ static_assert(( std::__is_forward_iterator <random_access_iterator<char *> >::value), "" );
+ static_assert(( std::__is_bidirectional_iterator<random_access_iterator<char *> >::value), "" );
+ static_assert(( std::__is_random_access_iterator<random_access_iterator<char *> >::value), "" );
+ static_assert((!std::__is_exactly_input_iterator<random_access_iterator<char *> >::value), "" );
- static_assert(( std::__is_input_iterator <my_input_iterator<char *> >::value), "" );
- static_assert((!std::__is_forward_iterator <my_input_iterator<char *> >::value), "" );
- static_assert((!std::__is_bidirectional_iterator<my_input_iterator<char *> >::value), "" );
- static_assert((!std::__is_random_access_iterator<my_input_iterator<char *> >::value), "" );
- static_assert(( std::__is_exactly_input_iterator<my_input_iterator<char *> >::value), "" );
+ static_assert(( std::__is_input_iterator <my_input_iterator<char *> >::value), "" );
+ static_assert((!std::__is_forward_iterator <my_input_iterator<char *> >::value), "" );
+ static_assert((!std::__is_bidirectional_iterator<my_input_iterator<char *> >::value), "" );
+ static_assert((!std::__is_random_access_iterator<my_input_iterator<char *> >::value), "" );
+ static_assert(( std::__is_exactly_input_iterator<my_input_iterator<char *> >::value), "" );
//
// iterators from libc++'s containers
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.overview/nothing_to_do.pass.cpp b/test/libcxx/language.support/cxa_deleted_virtual.pass.cpp
similarity index 64%
rename from test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.overview/nothing_to_do.pass.cpp
rename to test/libcxx/language.support/cxa_deleted_virtual.pass.cpp
index b58f5c5..39e884b 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.overview/nothing_to_do.pass.cpp
+++ b/test/libcxx/language.support/cxa_deleted_virtual.pass.cpp
@@ -7,6 +7,12 @@
//
//===----------------------------------------------------------------------===//
-int main()
-{
+// UNSUPPORTED: c++98, c++03
+
+// Test exporting the symbol: "__cxa_deleted_virtual" in macosx
+
+struct S { virtual void f() = delete; virtual ~S() {} };
+int main() {
+ S *s = new S;
+ delete s;
}
diff --git a/test/libcxx/numerics/c.math/constexpr-fns.pass.cpp b/test/libcxx/numerics/c.math/constexpr-fns.pass.cpp
index 9123be1..a58c389 100644
--- a/test/libcxx/numerics/c.math/constexpr-fns.pass.cpp
+++ b/test/libcxx/numerics/c.math/constexpr-fns.pass.cpp
@@ -23,9 +23,9 @@
#include <cmath>
-static_assert(std::__libcpp_isnan(0.) == false, "");
-static_assert(std::__libcpp_isinf(0.0) == false, "");
-static_assert(std::__libcpp_isfinite(0.0) == true, "");
+static_assert(std::__libcpp_isnan_or_builtin(0.) == false, "");
+static_assert(std::__libcpp_isinf_or_builtin(0.0) == false, "");
+static_assert(std::__libcpp_isfinite_or_builtin(0.0) == true, "");
int main()
{
diff --git a/test/libcxx/numerics/c.math/fdelayed-template-parsing.sh.cpp b/test/libcxx/numerics/c.math/fdelayed-template-parsing.sh.cpp
new file mode 100644
index 0000000..37aaa2a
--- /dev/null
+++ b/test/libcxx/numerics/c.math/fdelayed-template-parsing.sh.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.
+//
+//===----------------------------------------------------------------------===//
+
+// test that cmath builds with -fdelayed-template-parsing
+
+// REQUIRES: fdelayed-template-parsing
+
+// RUN: %build -fdelayed-template-parsing
+// RUN: %run
+
+#include <cmath>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main() {
+ assert(std::isfinite(1.0));
+ assert(!std::isinf(1.0));
+ assert(!std::isnan(1.0));
+}
+
+using namespace std;
diff --git a/test/libcxx/numerics/complex.number/ccmplx/ccomplex.pass.cpp b/test/libcxx/numerics/complex.number/ccmplx/ccomplex.pass.cpp
index 21aaa66..cc98517 100644
--- a/test/libcxx/numerics/complex.number/ccmplx/ccomplex.pass.cpp
+++ b/test/libcxx/numerics/complex.number/ccmplx/ccomplex.pass.cpp
@@ -18,4 +18,5 @@
int main()
{
std::complex<double> d;
+ (void)d;
}
diff --git a/test/libcxx/strings/iterators.noexcept.pass.cpp b/test/libcxx/strings/iterators.noexcept.pass.cpp
index 20b4e3d..c9d2bf5 100644
--- a/test/libcxx/strings/iterators.noexcept.pass.cpp
+++ b/test/libcxx/strings/iterators.noexcept.pass.cpp
@@ -20,7 +20,7 @@
//
// MODULES_DEFINES: _LIBCPP_NO_EXCEPTIONS
-#define _LIBCPP_NO_EXCEPTIONS
+#define _LIBCPP_NO_EXCEPTIONS
#include <iterator>
#include <cassert>
diff --git a/test/libcxx/thread/thread.condition/PR30202_notify_from_pthread_created_thread.pass.cpp b/test/libcxx/thread/thread.condition/PR30202_notify_from_pthread_created_thread.pass.cpp
index de225fe..7463b78 100644
--- a/test/libcxx/thread/thread.condition/PR30202_notify_from_pthread_created_thread.pass.cpp
+++ b/test/libcxx/thread/thread.condition/PR30202_notify_from_pthread_created_thread.pass.cpp
@@ -20,7 +20,7 @@
// notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
// Test that this function works with threads that were not created by
-// std::thread. See http://llvm.org/PR30202.
+// std::thread. See: https://bugs.llvm.org/show_bug.cgi?id=30202
#include <condition_variable>
diff --git a/test/libcxx/type_traits/lazy_metafunctions.pass.cpp b/test/libcxx/type_traits/lazy_metafunctions.pass.cpp
index 8f75080..8cf47a0 100644
--- a/test/libcxx/type_traits/lazy_metafunctions.pass.cpp
+++ b/test/libcxx/type_traits/lazy_metafunctions.pass.cpp
@@ -134,4 +134,4 @@
LazyNotTest();
LazyAndTest();
LazyOrTest();
-}
\ No newline at end of file
+}
diff --git a/test/libcxx/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp b/test/libcxx/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp
index 803c501..58bb5fd 100644
--- a/test/libcxx/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp
+++ b/test/libcxx/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp
@@ -213,4 +213,4 @@
TestCase<ArgType volatile>::run();
TestCase<ArgType const volatile>::run();
TestCase<ArgType*>::run();
-}
\ No newline at end of file
+}
diff --git a/test/libcxx/utilities/memory/util.smartptr/util.smartptr.shared/function_type_default_deleter.fail.cpp b/test/libcxx/utilities/memory/util.smartptr/util.smartptr.shared/function_type_default_deleter.fail.cpp
index 87cd292..c94ce75 100644
--- a/test/libcxx/utilities/memory/util.smartptr/util.smartptr.shared/function_type_default_deleter.fail.cpp
+++ b/test/libcxx/utilities/memory/util.smartptr/util.smartptr.shared/function_type_default_deleter.fail.cpp
@@ -36,7 +36,7 @@
SPtr<2> s2(getFn<2>(), Deleter{}); // OK
SPtr<3> s3(nullptr, Deleter{}); // OK
}
- // expected-error@memory:* 2 {{static_assert failed "default_delete cannot be instantiated for function types"}}
+ // expected-error-re@memory:* 2 {{static_assert failed{{.*}} "default_delete cannot be instantiated for function types"}}
{
SPtr<4> s4(getFn<4>()); // expected-note {{requested here}}
SPtr<5> s5(getFn<5>(), std::default_delete<FnType<5>>{}); // expected-note {{requested here}}
diff --git a/test/libcxx/utilities/optional/optional.object/special_member_gen.pass.cpp b/test/libcxx/utilities/optional/optional.object/special_member_gen.pass.cpp
deleted file mode 100644
index 9493d6b..0000000
--- a/test/libcxx/utilities/optional/optional.object/special_member_gen.pass.cpp
+++ /dev/null
@@ -1,66 +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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11, c++14
-// <optional>
-
-
-#include <optional>
-#include <type_traits>
-#include <cassert>
-
-#include "archetypes.hpp"
-
-template <class T>
-struct SpecialMemberTest {
- using O = std::optional<T>;
-
- template <template <class> class TestMF>
- static constexpr bool check_same() {
- return TestMF<O>::value == TestMF<T>::value;
- }
-
- // Test that optional inherits the correct trivial/non-trivial members
- static_assert(check_same<std::is_trivially_destructible>(), "");
- static_assert(check_same<std::is_trivially_copyable>(), "");
-};
-
-template <class ...Args> static void sink(Args&&...) {}
-
-template <class ...TestTypes>
-struct DoTestsMetafunction {
- DoTestsMetafunction() { sink(SpecialMemberTest<TestTypes>{}...); }
-};
-
-struct TrivialMoveNonTrivialCopy {
- TrivialMoveNonTrivialCopy() = default;
- TrivialMoveNonTrivialCopy(const TrivialMoveNonTrivialCopy&) {}
- TrivialMoveNonTrivialCopy(TrivialMoveNonTrivialCopy&&) = default;
- TrivialMoveNonTrivialCopy& operator=(const TrivialMoveNonTrivialCopy&) { return *this; }
- TrivialMoveNonTrivialCopy& operator=(TrivialMoveNonTrivialCopy&&) = default;
-};
-
-struct TrivialCopyNonTrivialMove {
- TrivialCopyNonTrivialMove() = default;
- TrivialCopyNonTrivialMove(const TrivialCopyNonTrivialMove&) = default;
- TrivialCopyNonTrivialMove(TrivialCopyNonTrivialMove&&) {}
- TrivialCopyNonTrivialMove& operator=(const TrivialCopyNonTrivialMove&) = default;
- TrivialCopyNonTrivialMove& operator=(TrivialCopyNonTrivialMove&&) { return *this; }
-};
-
-int main()
-{
- sink(
- ImplicitTypes::ApplyTypes<DoTestsMetafunction>{},
- ExplicitTypes::ApplyTypes<DoTestsMetafunction>{},
- NonLiteralTypes::ApplyTypes<DoTestsMetafunction>{},
- NonTrivialTypes::ApplyTypes<DoTestsMetafunction>{},
- DoTestsMetafunction<TrivialMoveNonTrivialCopy, TrivialCopyNonTrivialMove>{}
- );
-}
diff --git a/test/libcxx/utilities/tuple/tuple.tuple/diagnose_reference_binding.fail.cpp b/test/libcxx/utilities/tuple/tuple.tuple/diagnose_reference_binding.fail.cpp
index 76d5f0d..1cc3c73 100644
--- a/test/libcxx/utilities/tuple/tuple.tuple/diagnose_reference_binding.fail.cpp
+++ b/test/libcxx/utilities/tuple/tuple.tuple/diagnose_reference_binding.fail.cpp
@@ -22,7 +22,7 @@
int main() {
std::allocator<void> alloc;
- // expected-error@tuple:* 4 {{static_assert failed "Attempted to construct a reference element in a tuple with an rvalue"}}
+ // expected-error-re@tuple:* 4 {{static_assert failed{{.*}} "Attempted to construct a reference element in a tuple with an rvalue"}}
// bind lvalue to rvalue
std::tuple<int const&> t(42); // expected-note {{requested here}}
diff --git a/test/libcxx/utilities/tuple/tuple.tuple/diagnose_reference_binding.pass.cpp b/test/libcxx/utilities/tuple/tuple.tuple/diagnose_reference_binding.pass.cpp
index a90a291..7844697 100644
--- a/test/libcxx/utilities/tuple/tuple.tuple/diagnose_reference_binding.pass.cpp
+++ b/test/libcxx/utilities/tuple/tuple.tuple/diagnose_reference_binding.pass.cpp
@@ -68,4 +68,4 @@
std::tuple<int const&> t4(std::allocator_arg, alloc, cr);
assert(&std::get<0>(t4) == &x);
}
-}
\ No newline at end of file
+}
diff --git a/test/std/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp
index ec0526c..b837a0e 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp
@@ -21,10 +21,10 @@
#include "test_iterators.h"
struct eq {
- eq (int val) : v(val) {}
- bool operator () (int v2) const { return v == v2; }
- int v;
- };
+ eq (int val) : v(val) {}
+ bool operator () (int v2) const { return v == v2; }
+ int v;
+ };
int main()
diff --git a/test/std/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp
index 761d71b..fa1faf1 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp
@@ -21,10 +21,10 @@
#include "test_iterators.h"
struct eq {
- eq (int val) : v(val) {}
- bool operator () (int v2) const { return v == v2; }
- int v;
- };
+ eq (int val) : v(val) {}
+ bool operator () (int v2) const { return v == v2; }
+ int v;
+ };
int main()
{
diff --git a/test/std/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp
index 2e52e26..1f3c34b 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp
@@ -21,10 +21,10 @@
#include "test_iterators.h"
struct ne {
- ne (int val) : v(val) {}
- bool operator () (int v2) const { return v != v2; }
- int v;
- };
+ ne (int val) : v(val) {}
+ bool operator () (int v2) const { return v != v2; }
+ int v;
+ };
int main()
diff --git a/test/std/algorithms/alg.nonmodifying/alg.foreach/for_each_n.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.foreach/for_each_n.pass.cpp
index fd24edb..9b391f0 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.foreach/for_each_n.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.foreach/for_each_n.pass.cpp
@@ -36,15 +36,15 @@
auto f = for_each_test(0);
Iter it = std::for_each_n(Iter(ia), 0, std::ref(f));
assert(it == Iter(ia));
- assert(f.count == 0);
+ assert(f.count == 0);
}
{
auto f = for_each_test(0);
Iter it = std::for_each_n(Iter(ia), s, std::ref(f));
-
+
assert(it == Iter(ia+s));
- assert(f.count == s);
+ assert(f.count == s);
for (unsigned i = 0; i < s; ++i)
assert(ia[i] == static_cast<int>(i+1));
}
@@ -52,9 +52,9 @@
{
auto f = for_each_test(0);
Iter it = std::for_each_n(Iter(ia), 1, std::ref(f));
-
+
assert(it == Iter(ia+1));
- assert(f.count == 1);
+ assert(f.count == 1);
for (unsigned i = 0; i < 1; ++i)
assert(ia[i] == static_cast<int>(i+2));
}
diff --git a/test/std/algorithms/alg.nonmodifying/mismatch/mismatch.pass.cpp b/test/std/algorithms/alg.nonmodifying/mismatch/mismatch.pass.cpp
index eb37cca..d4bc3fd 100644
--- a/test/std/algorithms/alg.nonmodifying/mismatch/mismatch.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/mismatch/mismatch.pass.cpp
@@ -26,7 +26,7 @@
int ia[] = {0, 1, 2, 2, 0, 1, 2, 3};
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
+ 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;
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 d78809b..2a36382 100644
--- a/test/std/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp
@@ -32,7 +32,7 @@
int ia[] = {0, 1, 2, 2, 0, 1, 2, 3};
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
+ 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;
diff --git a/test/std/algorithms/alg.sorting/alg.clamp/clamp.pass.cpp b/test/std/algorithms/alg.sorting/alg.clamp/clamp.pass.cpp
index 1e18720..7d73414 100644
--- a/test/std/algorithms/alg.sorting/alg.clamp/clamp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.clamp/clamp.pass.cpp
@@ -18,13 +18,13 @@
#include <cassert>
struct Tag {
- Tag() : val(0), tag("Default") {}
- Tag(int a, const char *b) : val(a), tag(b) {}
- ~Tag() {}
+ Tag() : val(0), tag("Default") {}
+ Tag(int a, const char *b) : val(a), tag(b) {}
+ ~Tag() {}
- int val;
- const char *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; }
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 683b07d..3743fa5 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
@@ -23,24 +23,24 @@
#if TEST_STD_VER >= 11
struct S {
- S() : i_(0) {}
- S(int i) : i_(i) {}
+ 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(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; }
+ 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; }
+ 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; }
+ void set(int i) { i_ = i; }
- int i_;
- };
+ int i_;
+ };
#endif
std::mt19937 randomness;
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 3d8902e..992862a 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
@@ -33,25 +33,25 @@
};
struct S {
- S() : i_(0) {}
- S(int i) : i_(i) {}
+ 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(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; }
+ 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; }
+ 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; }
+ void set(int i) { i_ = i; }
- int i_;
- };
+ int i_;
+ };
#endif // TEST_STD_VER >= 11
@@ -116,6 +116,26 @@
test<Iter>(1000);
}
+struct less_by_first {
+ template <typename Pair>
+ bool operator()(const Pair& lhs, const Pair& rhs) {
+ return std::less<typename Pair::first_type>()(lhs.first, rhs.first);
+ }
+};
+
+void test_PR31166 ()
+{
+ typedef std::pair<int, int> P;
+ typedef std::vector<P> V;
+ P vec[5] = {P(1, 0), P(2, 0), P(2, 1), P(2, 2), P(2, 3)};
+ for ( int i = 0; i < 5; ++i ) {
+ V res(vec, vec + 5);
+ std::inplace_merge(res.begin(), res.begin() + i, res.end(), less_by_first());
+ assert(res.size() == 5);
+ assert(std::equal(res.begin(), res.end(), vec));
+ }
+}
+
int main()
{
test<bidirectional_iterator<int*> >();
@@ -146,4 +166,6 @@
delete [] ia;
}
#endif // TEST_STD_VER >= 11
+
+ test_PR31166();
}
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 402d57d..da76d2a 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
@@ -87,8 +87,8 @@
void constexpr_test()
{
#if TEST_STD_VER >= 14
- constexpr auto p = std::min_element(il, il+8, less());
- static_assert(*p == 1, "");
+ constexpr auto p = std::min_element(il, il+8, less());
+ static_assert(*p == 1, "");
#endif
}
diff --git a/test/std/atomics/atomics.lockfree/isalwayslockfree.pass.cpp b/test/std/atomics/atomics.lockfree/isalwayslockfree.pass.cpp
index e42e9f2..7a4090b 100644
--- a/test/std/atomics/atomics.lockfree/isalwayslockfree.pass.cpp
+++ b/test/std/atomics/atomics.lockfree/isalwayslockfree.pass.cpp
@@ -25,6 +25,40 @@
assert(std::atomic<T>().is_lock_free());
}
+// FIXME: This separate test is needed to work around llvm.org/PR31864
+// which causes ATOMIC_LLONG_LOCK_FREE to be defined as '1' in 32-bit builds
+// even though __atomic_always_lock_free returns true for the same type.
+constexpr bool NeedWorkaroundForPR31864 =
+#if defined(__clang__)
+(sizeof(void*) == 4); // Needed on 32 bit builds
+#else
+false;
+#endif
+
+template <bool Disable = NeedWorkaroundForPR31864,
+ std::enable_if_t<!Disable>* = nullptr,
+ class LLong = long long,
+ class ULLong = unsigned long long>
+void checkLongLongTypes() {
+ static_assert(std::atomic<LLong>::is_always_lock_free == (2 == ATOMIC_LLONG_LOCK_FREE));
+ static_assert(std::atomic<ULLong>::is_always_lock_free == (2 == ATOMIC_LLONG_LOCK_FREE));
+}
+
+// Used to make the calls to __atomic_always_lock_free dependent on a template
+// parameter.
+template <class T> constexpr size_t getSizeOf() { return sizeof(T); }
+
+template <bool Enable = NeedWorkaroundForPR31864,
+ std::enable_if_t<Enable>* = nullptr,
+ class LLong = long long,
+ class ULLong = unsigned long long>
+void checkLongLongTypes() {
+ constexpr bool ExpectLockFree = __atomic_always_lock_free(getSizeOf<LLong>(), 0);
+ static_assert(std::atomic<LLong>::is_always_lock_free == ExpectLockFree, "");
+ static_assert(std::atomic<ULLong>::is_always_lock_free == ExpectLockFree, "");
+ static_assert((0 != ATOMIC_LLONG_LOCK_FREE) == ExpectLockFree, "");
+}
+
int main()
{
// structs and unions can't be defined in the template invocation.
@@ -94,8 +128,7 @@
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));
+ checkLongLongTypes();
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.types.generic/integral.pass.cpp b/test/std/atomics/atomics.types.generic/integral.pass.cpp
index 63cc02b..74b8c60 100644
--- a/test/std/atomics/atomics.types.generic/integral.pass.cpp
+++ b/test/std/atomics/atomics.types.generic/integral.pass.cpp
@@ -187,14 +187,14 @@
#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<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>();
@@ -213,12 +213,12 @@
#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>();
+ 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.operations/atomics.types.operations.req/atomic_helpers.h b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_helpers.h
index 482b731..2ba561f 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
@@ -43,14 +43,14 @@
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>()();
+ TestFunctor< int8_t>()();
+ TestFunctor< uint8_t>()();
+ TestFunctor< int16_t>()();
+ TestFunctor<uint16_t>()();
+ TestFunctor< int32_t>()();
+ TestFunctor<uint32_t>()();
+ TestFunctor< int64_t>()();
+ TestFunctor<uint64_t>()();
}
};
diff --git a/test/std/containers/Emplaceable.h b/test/std/containers/Emplaceable.h
index f9319d4..331a81f 100644
--- a/test/std/containers/Emplaceable.h
+++ b/test/std/containers/Emplaceable.h
@@ -45,8 +45,10 @@
template <>
struct hash<Emplaceable>
- : public std::unary_function<Emplaceable, std::size_t>
{
+ typedef Emplaceable argument_type;
+ typedef std::size_t result_type;
+
std::size_t operator()(const Emplaceable& x) const {return x.get();}
};
diff --git a/test/std/containers/NotConstructible.h b/test/std/containers/NotConstructible.h
index ac8b98e..55e6480 100644
--- a/test/std/containers/NotConstructible.h
+++ b/test/std/containers/NotConstructible.h
@@ -29,8 +29,10 @@
template <>
struct hash<NotConstructible>
- : public std::unary_function<NotConstructible, std::size_t>
{
+ typedef NotConstructible argument_type;
+ typedef std::size_t result_type;
+
std::size_t operator()(const NotConstructible&) const {return 0;}
};
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
index 210c270..a1fde84 100644
--- 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
@@ -16,14 +16,14 @@
template <class T>
struct Comp {
- bool operator () (const T& lhs, const T& rhs) const { return lhs < rhs; }
+ bool operator () (const T& lhs, const T& rhs) const { return lhs < rhs; }
- Comp () {}
+ Comp () {}
private:
- Comp (const Comp &); // declared but not defined
- };
+ Comp (const Comp &); // declared but not defined
+ };
int main() {
- std::map<int, int, Comp<int> > m;
+ std::map<int, int, Comp<int> > m;
}
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
index 3d33f72..ee96ed0 100644
--- 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
@@ -16,14 +16,14 @@
template <class T>
struct Comp {
- bool operator () (const T& lhs, const T& rhs) const { return lhs < rhs; }
+ bool operator () (const T& lhs, const T& rhs) const { return lhs < rhs; }
- Comp () {}
+ Comp () {}
private:
- Comp (const Comp &); // declared but not defined
- };
+ Comp (const Comp &); // declared but not defined
+ };
int main() {
- std::multimap<int, int, Comp<int> > m;
+ std::multimap<int, int, Comp<int> > m;
}
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
index 9287a03..4f9a6d6 100644
--- 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
@@ -16,14 +16,14 @@
template <class T>
struct Comp {
- bool operator () (const T& lhs, const T& rhs) const { return lhs < rhs; }
+ bool operator () (const T& lhs, const T& rhs) const { return lhs < rhs; }
- Comp () {}
+ Comp () {}
private:
- Comp (const Comp &); // declared but not defined
- };
+ Comp (const Comp &); // declared but not defined
+ };
int main() {
- std::multiset<int, Comp<int> > m;
+ std::multiset<int, Comp<int> > m;
}
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
index 858ee41..94ce9cd 100644
--- 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
@@ -16,14 +16,14 @@
template <class T>
struct Comp {
- bool operator () (const T& lhs, const T& rhs) const { return lhs < rhs; }
+ bool operator () (const T& lhs, const T& rhs) const { return lhs < rhs; }
- Comp () {}
+ Comp () {}
private:
- Comp (const Comp &); // declared but not defined
- };
+ Comp (const Comp &); // declared but not defined
+ };
int main() {
- std::set<int, Comp<int> > m;
+ std::set<int, Comp<int> > m;
}
diff --git a/test/std/containers/container.adaptors/priority.queue/types.fail.cpp b/test/std/containers/container.adaptors/priority.queue/types.fail.cpp
index 0d3025e..832f090 100644
--- a/test/std/containers/container.adaptors/priority.queue/types.fail.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/types.fail.cpp
@@ -31,5 +31,5 @@
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;
+ std::priority_queue<double, std::deque<int>> t;
}
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
index 2b8341f..4bd90a8 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/types.fail.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/types.fail.cpp
@@ -16,5 +16,5 @@
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;
+ std::queue<double, std::deque<int>> t;
}
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
index ee4c544..1cfa8e4 100644
--- a/test/std/containers/container.adaptors/stack/stack.defn/types.fail.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.defn/types.fail.cpp
@@ -31,5 +31,5 @@
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;
+ std::stack<double, std::deque<int>> t;
}
diff --git a/test/std/containers/sequences/array/at.pass.cpp b/test/std/containers/sequences/array/at.pass.cpp
index efec4e4..712a4da 100644
--- a/test/std/containers/sequences/array/at.pass.cpp
+++ b/test/std/containers/sequences/array/at.pass.cpp
@@ -27,7 +27,7 @@
constexpr bool check_idx( size_t idx, double val )
{
std::array<double, 3> arr = {1, 2, 3.5};
- return arr.at(idx) == val;
+ return arr.at(idx) == val;
}
#endif
diff --git a/test/std/containers/sequences/array/front_back.pass.cpp b/test/std/containers/sequences/array/front_back.pass.cpp
index 68fc6cd..0591ca7 100644
--- a/test/std/containers/sequences/array/front_back.pass.cpp
+++ b/test/std/containers/sequences/array/front_back.pass.cpp
@@ -27,13 +27,13 @@
constexpr bool check_front( double val )
{
std::array<double, 3> arr = {1, 2, 3.5};
- return arr.front() == val;
+ return arr.front() == val;
}
constexpr bool check_back( double val )
{
std::array<double, 3> arr = {1, 2, 3.5};
- return arr.back() == val;
+ return arr.back() == val;
}
#endif
diff --git a/test/std/containers/sequences/array/indexing.pass.cpp b/test/std/containers/sequences/array/indexing.pass.cpp
index 3a5b9ee..43c4947 100644
--- a/test/std/containers/sequences/array/indexing.pass.cpp
+++ b/test/std/containers/sequences/array/indexing.pass.cpp
@@ -27,7 +27,7 @@
constexpr bool check_idx( size_t idx, double val )
{
std::array<double, 3> arr = {1, 2, 3.5};
- return arr[idx] == val;
+ return arr[idx] == val;
}
#endif
diff --git a/test/std/containers/sequences/deque/deque.cons/assign_iter_iter.pass.cpp b/test/std/containers/sequences/deque/deque.cons/assign_iter_iter.pass.cpp
index f060677..940d4e8 100644
--- a/test/std/containers/sequences/deque/deque.cons/assign_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/assign_iter_iter.pass.cpp
@@ -19,6 +19,9 @@
#include "test_macros.h"
#include "test_iterators.h"
#include "min_allocator.h"
+#if TEST_STD_VER >= 11
+#include "emplace_constructible.h"
+#endif
template <class C>
C
@@ -80,7 +83,7 @@
testI(c1, c2);
}
-int main()
+void basic_test()
{
{
int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -103,3 +106,51 @@
}
#endif
}
+
+void test_emplacable_concept() {
+#if TEST_STD_VER >= 11
+ int arr1[] = {42};
+ int arr2[] = {1, 101, 42};
+ {
+ using T = EmplaceConstructibleMoveableAndAssignable<int>;
+ using It = random_access_iterator<int*>;
+ {
+ std::deque<T> v;
+ v.assign(It(arr1), It(std::end(arr1)));
+ assert(v[0].value == 42);
+ }
+ {
+ std::deque<T> v;
+ v.assign(It(arr2), It(std::end(arr2)));
+ assert(v[0].value == 1);
+ assert(v[1].value == 101);
+ assert(v[2].value == 42);
+ }
+ }
+ {
+ using T = EmplaceConstructibleMoveableAndAssignable<int>;
+ using It = input_iterator<int*>;
+ {
+ std::deque<T> v;
+ v.assign(It(arr1), It(std::end(arr1)));
+ assert(v[0].copied == 0);
+ assert(v[0].value == 42);
+ }
+ {
+ std::deque<T> v;
+ v.assign(It(arr2), It(std::end(arr2)));
+ //assert(v[0].copied == 0);
+ assert(v[0].value == 1);
+ //assert(v[1].copied == 0);
+ assert(v[1].value == 101);
+ assert(v[2].copied == 0);
+ assert(v[2].value == 42);
+ }
+ }
+#endif
+}
+
+int main() {
+ basic_test();
+ test_emplacable_concept();
+}
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 87445c5..793f2b1 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
@@ -15,9 +15,13 @@
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
#include "test_allocator.h"
#include "test_iterators.h"
#include "min_allocator.h"
+#if TEST_STD_VER >= 11
+#include "emplace_constructible.h"
+#endif
template <class InputIterator>
void
@@ -48,7 +52,7 @@
assert(*i == *f);
}
-int main()
+void basic_test()
{
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]);
@@ -61,3 +65,48 @@
test<min_allocator<int> >(ab, an);
#endif
}
+
+
+void test_emplacable_concept() {
+#if TEST_STD_VER >= 11
+ int arr1[] = {42};
+ int arr2[] = {1, 101, 42};
+ {
+ using T = EmplaceConstructibleAndMoveable<int>;
+ using It = random_access_iterator<int*>;
+ {
+ std::deque<T> v(It(arr1), It(std::end(arr1)));
+ assert(v[0].value == 42);
+ }
+ {
+ std::deque<T> v(It(arr2), It(std::end(arr2)));
+ assert(v[0].value == 1);
+ assert(v[1].value == 101);
+ assert(v[2].value == 42);
+ }
+ }
+ {
+ using T = EmplaceConstructibleAndMoveable<int>;
+ using It = input_iterator<int*>;
+ {
+ std::deque<T> v(It(arr1), It(std::end(arr1)));
+ assert(v[0].copied == 0);
+ assert(v[0].value == 42);
+ }
+ {
+ std::deque<T> v(It(arr2), It(std::end(arr2)));
+ //assert(v[0].copied == 0);
+ assert(v[0].value == 1);
+ //assert(v[1].copied == 0);
+ assert(v[1].value == 101);
+ assert(v[2].copied == 0);
+ assert(v[2].value == 42);
+ }
+ }
+#endif
+}
+
+int main() {
+ basic_test();
+ test_emplacable_concept();
+}
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 54227eb..9ac342a 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
@@ -16,9 +16,13 @@
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
#include "test_iterators.h"
#include "test_allocator.h"
#include "min_allocator.h"
+#if TEST_STD_VER >= 11
+#include "emplace_constructible.h"
+#endif
template <class InputIterator, class Allocator>
void
@@ -35,7 +39,7 @@
assert(*i == *f);
}
-int main()
+void basic_test()
{
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]);
@@ -50,3 +54,50 @@
test(random_access_iterator<const int*>(ab), random_access_iterator<const int*>(an), min_allocator<int>());
#endif
}
+
+
+void test_emplacable_concept() {
+#if TEST_STD_VER >= 11
+ int arr1[] = {42};
+ int arr2[] = {1, 101, 42};
+ {
+ using T = EmplaceConstructibleAndMoveable<int>;
+ using It = random_access_iterator<int*>;
+ std::allocator<T> a;
+ {
+ std::deque<T> v(It(arr1), It(std::end(arr1)), a);
+ assert(v[0].value == 42);
+ }
+ {
+ std::deque<T> v(It(arr2), It(std::end(arr2)), a);
+ assert(v[0].value == 1);
+ assert(v[1].value == 101);
+ assert(v[2].value == 42);
+ }
+ }
+ {
+ using T = EmplaceConstructibleAndMoveable<int>;
+ using It = input_iterator<int*>;
+ std::allocator<T> a;
+ {
+ std::deque<T> v(It(arr1), It(std::end(arr1)), a);
+ assert(v[0].copied == 0);
+ assert(v[0].value == 42);
+ }
+ {
+ std::deque<T> v(It(arr2), It(std::end(arr2)), a);
+ //assert(v[0].copied == 0);
+ assert(v[0].value == 1);
+ //assert(v[1].copied == 0);
+ assert(v[1].value == 101);
+ assert(v[2].copied == 0);
+ assert(v[2].value == 42);
+ }
+ }
+#endif
+}
+
+int main() {
+ basic_test();
+ test_emplacable_concept();
+}
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 fdf67d2..baae755 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
@@ -45,9 +45,9 @@
typedef std::deque<MoveOnly, other_allocator<MoveOnly>> C;
static_assert(std::is_nothrow_move_constructible<C>::value, "");
}
-#endif // _LIBCPP_VERSION
{
typedef std::deque<MoveOnly, some_alloc<MoveOnly>> C;
static_assert(!std::is_nothrow_move_constructible<C>::value, "");
}
+#endif // _LIBCPP_VERSION
}
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 db22086..4c1e15f 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
@@ -80,17 +80,17 @@
assert(false);
}
catch (...) {
- gCopyConstructorShouldThow = false;
+ gCopyConstructorShouldThow = false;
assert(vec==vec2);
}
- }
+ }
- {
- typedef std::deque<CMyClass, test_allocator<CMyClass> > C;
+ {
+ typedef std::deque<CMyClass, test_allocator<CMyClass> > C;
C vec;
C vec2(vec);
- C::allocator_type::throw_after = 1;
+ C::allocator_type::throw_after = 1;
try {
vec.push_back(instance);
assert(false);
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 7a90c8a..0688ed0 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
@@ -80,17 +80,17 @@
assert(false);
}
catch (...) {
- gCopyConstructorShouldThow = false;
+ gCopyConstructorShouldThow = false;
assert(vec==vec2);
}
- }
+ }
- {
- typedef std::deque<CMyClass, test_allocator<CMyClass> > C;
+ {
+ typedef std::deque<CMyClass, test_allocator<CMyClass> > C;
C vec;
C vec2(vec);
- C::allocator_type::throw_after = 1;
+ C::allocator_type::throw_after = 1;
try {
vec.push_front(instance);
assert(false);
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 0db30a0..01a1096 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
@@ -72,7 +72,7 @@
{
typedef std::deque<MoveOnly, some_alloc<MoveOnly>> C;
#if TEST_STD_VER >= 14
- // In c++14, if POCS is set, swapping the allocator is required not to throw
+ // In C++14, if POCS is set, swapping the allocator is required not to throw
static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
#else
static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
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 3390c33..a4c776a 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
@@ -45,9 +45,9 @@
typedef std::forward_list<MoveOnly, other_allocator<MoveOnly>> C;
static_assert(std::is_nothrow_move_constructible<C>::value, "");
}
-#endif // _LIBCPP_VERSION
{
typedef std::forward_list<MoveOnly, some_alloc<MoveOnly>> C;
static_assert(!std::is_nothrow_move_constructible<C>::value, "");
}
+#endif // _LIBCPP_VERSION
}
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 d93c079..ae48d1a 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
@@ -72,7 +72,7 @@
{
typedef std::forward_list<MoveOnly, some_alloc<MoveOnly>> C;
#if TEST_STD_VER >= 14
- // In c++14, if POCS is set, swapping the allocator is required not to throw
+ // In C++14, if POCS is set, swapping the allocator is required not to throw
static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
#else
static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
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 3b3c2f7..3cdcc73 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
@@ -17,8 +17,12 @@
#include "test_iterators.h"
#include "test_allocator.h"
#include "min_allocator.h"
+#if TEST_STD_VER >= 11
+#include "emplace_constructible.h"
+#include "container_test_types.h"
+#endif
-int main()
+void basic_test()
{
{
int a[] = {0, 1, 2, 3};
@@ -76,3 +80,179 @@
}
#endif
}
+
+
+
+void test_emplacable_concept() {
+#if TEST_STD_VER >= 11
+ int arr1[] = {42};
+ int arr2[] = {1, 101, 42};
+ {
+ using T = EmplaceConstructible<int>;
+ using It = random_access_iterator<int*>;
+ {
+ std::list<T> v(It(arr1), It(std::end(arr1)));
+ auto I = v.begin();
+ assert(I->value == 42);
+ }
+ {
+ std::list<T> v(It(arr2), It(std::end(arr2)));
+ auto I = v.begin();
+ assert(I->value == 1);
+ ++I;
+ assert(I->value == 101);
+ ++I;
+ assert(I->value == 42);
+ }
+ }
+ {
+ using T = EmplaceConstructible<int>;
+ using It = input_iterator<int*>;
+ {
+ std::list<T> v(It(arr1), It(std::end(arr1)));
+ auto I = v.begin();
+ assert(I->value == 42);
+ }
+ {
+ std::list<T> v(It(arr2), It(std::end(arr2)));
+ auto I = v.begin();
+ //assert(v[0].copied == 0);
+ assert(I->value == 1);
+ //assert(v[1].copied == 0);
+ ++I;
+ assert(I->value == 101);
+ ++I;
+ assert(I->value == 42);
+ }
+ }
+#endif
+}
+
+
+
+void test_emplacable_concept_with_alloc() {
+#if TEST_STD_VER >= 11
+ int arr1[] = {42};
+ int arr2[] = {1, 101, 42};
+ {
+ using T = EmplaceConstructible<int>;
+ using It = random_access_iterator<int*>;
+ std::allocator<T> a;
+ {
+ std::list<T> v(It(arr1), It(std::end(arr1)), a);
+ auto I = v.begin();
+ assert(I->value == 42);
+ }
+ {
+ std::list<T> v(It(arr2), It(std::end(arr2)), a);
+ auto I = v.begin();
+ assert(I->value == 1);
+ ++I;
+ assert(I->value == 101);
+ ++I;
+ assert(I->value == 42);
+ }
+ }
+ {
+ using T = EmplaceConstructible<int>;
+ using It = input_iterator<int*>;
+ std::allocator<T> a;
+ {
+ std::list<T> v(It(arr1), It(std::end(arr1)), a);
+ auto I = v.begin();
+ assert(I->value == 42);
+ }
+ {
+ std::list<T> v(It(arr2), It(std::end(arr2)), a);
+ auto I = v.begin();
+ //assert(v[0].copied == 0);
+ assert(I->value == 1);
+ //assert(v[1].copied == 0);
+ ++I;
+ assert(I->value == 101);
+ ++I;
+ assert(I->value == 42);
+ }
+ }
+#endif
+}
+
+void test_ctor_under_alloc() {
+#if TEST_STD_VER >= 11
+ int arr1[] = {42};
+ int arr2[] = {1, 101, 42};
+ {
+ using C = TCT::list<>;
+ using T = typename C::value_type;
+ using It = forward_iterator<int*>;
+ {
+ ExpectConstructGuard<int&> G(1);
+ C v(It(arr1), It(std::end(arr1)));
+ }
+ {
+ ExpectConstructGuard<int&> G(3);
+ C v(It(arr2), It(std::end(arr2)));
+ }
+ }
+ {
+ using C = TCT::list<>;
+ using T = typename C::value_type;
+ using It = input_iterator<int*>;
+ {
+ ExpectConstructGuard<int&> G(1);
+ C v(It(arr1), It(std::end(arr1)));
+ }
+ {
+ ExpectConstructGuard<int&> G(3);
+ C v(It(arr2), It(std::end(arr2)));
+ }
+ }
+#endif
+}
+
+void test_ctor_under_alloc_with_alloc() {
+#if TEST_STD_VER >= 11
+ int arr1[] = {42};
+ int arr2[] = {1, 101, 42};
+ {
+ using C = TCT::list<>;
+ using T = typename C::value_type;
+ using It = forward_iterator<int*>;
+ using Alloc = typename C::allocator_type;
+ Alloc a;
+ {
+ ExpectConstructGuard<int&> G(1);
+ C v(It(arr1), It(std::end(arr1)), a);
+ }
+ {
+ ExpectConstructGuard<int&> G(3);
+ C v(It(arr2), It(std::end(arr2)), a);
+ }
+ }
+ {
+ using C = TCT::list<>;
+ using T = typename C::value_type;
+ using It = input_iterator<int*>;
+ using Alloc = typename C::allocator_type;
+ Alloc a;
+ {
+ ExpectConstructGuard<int&> G(1);
+ C v(It(arr1), It(std::end(arr1)), a);
+ }
+ {
+ ExpectConstructGuard<int&> G(3);
+ C v(It(arr2), It(std::end(arr2)), a);
+ }
+ }
+#endif
+}
+
+
+
+int main() {
+ basic_test();
+ test_emplacable_concept();
+ test_emplacable_concept_with_alloc();
+ test_ctor_under_alloc();
+ test_ctor_under_alloc_with_alloc();
+}
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 cfe1bfd..acb68f3 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
@@ -72,7 +72,7 @@
{
typedef std::list<MoveOnly, some_alloc<MoveOnly>> C;
#if TEST_STD_VER >= 14
- // In c++14, if POCS is set, swapping the allocator is required not to throw
+ // In C++14, if POCS is set, swapping the allocator is required not to throw
static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
#else
static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
diff --git a/test/std/containers/sequences/list/types.pass.cpp b/test/std/containers/sequences/list/types.pass.cpp
index 7d5f5b6..8c47606 100644
--- a/test/std/containers/sequences/list/types.pass.cpp
+++ b/test/std/containers/sequences/list/types.pass.cpp
@@ -31,8 +31,8 @@
int main()
{
- {
- typedef std::list<int> C;
+ {
+ 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), "");
@@ -46,11 +46,11 @@
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;
+ 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), "");
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 a18ba8f..0f51c21 100644
--- a/test/std/containers/sequences/vector.bool/construct_default.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/construct_default.pass.cpp
@@ -24,9 +24,9 @@
test0()
{
#if TEST_STD_VER > 14
- static_assert((noexcept(C{})), "" );
+ static_assert((noexcept(C{})), "" );
#elif TEST_STD_VER >= 11
- static_assert((noexcept(C()) == noexcept(typename C::allocator_type())), "" );
+ static_assert((noexcept(C()) == noexcept(typename C::allocator_type())), "" );
#endif
C c;
LIBCPP_ASSERT(c.__invariants());
@@ -45,9 +45,9 @@
test1(const typename C::allocator_type& a)
{
#if TEST_STD_VER > 14
- static_assert((noexcept(C{typename C::allocator_type{}})), "" );
+ static_assert((noexcept(C{typename C::allocator_type{}})), "" );
#elif TEST_STD_VER >= 11
- static_assert((noexcept(C(typename C::allocator_type())) == std::is_nothrow_copy_constructible<typename C::allocator_type>::value), "" );
+ static_assert((noexcept(C(typename C::allocator_type())) == std::is_nothrow_copy_constructible<typename C::allocator_type>::value), "" );
#endif
C c(a);
LIBCPP_ASSERT(c.__invariants());
diff --git a/test/std/containers/sequences/vector.bool/reference.swap.pass.cpp b/test/std/containers/sequences/vector.bool/reference.swap.pass.cpp
index 06351e4..8fe18d4 100644
--- a/test/std/containers/sequences/vector.bool/reference.swap.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/reference.swap.pass.cpp
@@ -23,17 +23,17 @@
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];
+ 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);
+ assert(!r1);
+ assert( r2);
+ v.swap(r1, r2);
+ assert( r1);
+ assert(!r2);
}
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 d888af0..68d04db 100644
--- a/test/std/containers/sequences/vector.bool/swap_noexcept.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/swap_noexcept.pass.cpp
@@ -72,7 +72,7 @@
{
#if TEST_STD_VER >= 14
#if defined(_LIBCPP_VERSION)
- // In c++14, if POCS is set, swapping the allocator is required not to throw
+ // In C++14, if POCS is set, swapping the allocator is required not to throw
typedef std::vector<bool, some_alloc<bool>> C;
static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
#endif // _LIBCPP_VERSION
diff --git a/test/std/containers/sequences/vector/vector.cons/assign_iter_iter.pass.cpp b/test/std/containers/sequences/vector/vector.cons/assign_iter_iter.pass.cpp
new file mode 100644
index 0000000..f074956
--- /dev/null
+++ b/test/std/containers/sequences/vector/vector.cons/assign_iter_iter.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <vector>
+
+// void assign(size_type n, const_reference v);
+
+#include <vector>
+#include <algorithm>
+#include <cassert>
+#include <iostream>
+#include "test_macros.h"
+#include "min_allocator.h"
+#include "asan_testing.h"
+#include "test_iterators.h"
+#if TEST_STD_VER >= 11
+#include "emplace_constructible.h"
+#include "container_test_types.h"
+#endif
+
+
+void test_emplaceable_concept() {
+#if TEST_STD_VER >= 11
+ int arr1[] = {42};
+ int arr2[] = {1, 101, 42};
+ {
+ using T = EmplaceConstructibleMoveableAndAssignable<int>;
+ using It = forward_iterator<int*>;
+ {
+ std::vector<T> v;
+ v.assign(It(arr1), It(std::end(arr1)));
+ assert(v[0].value == 42);
+ }
+ {
+ std::vector<T> v;
+ v.assign(It(arr2), It(std::end(arr2)));
+ assert(v[0].value == 1);
+ assert(v[1].value == 101);
+ assert(v[2].value == 42);
+ }
+ }
+ {
+ using T = EmplaceConstructibleMoveableAndAssignable<int>;
+ using It = input_iterator<int*>;
+ {
+ std::vector<T> v;
+ v.assign(It(arr1), It(std::end(arr1)));
+ assert(v[0].copied == 0);
+ assert(v[0].value == 42);
+ }
+ {
+ std::vector<T> v;
+ v.assign(It(arr2), It(std::end(arr2)));
+ //assert(v[0].copied == 0);
+ assert(v[0].value == 1);
+ //assert(v[1].copied == 0);
+ assert(v[1].value == 101);
+ assert(v[2].copied == 0);
+ assert(v[2].value == 42);
+ }
+ }
+#endif
+}
+
+
+
+int main()
+{
+ test_emplaceable_concept();
+}
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 edeae04..a71f5b3 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
@@ -27,9 +27,9 @@
test0()
{
#if TEST_STD_VER > 14
- static_assert((noexcept(C{})), "" );
+ static_assert((noexcept(C{})), "" );
#elif TEST_STD_VER >= 11
- static_assert((noexcept(C()) == noexcept(typename C::allocator_type())), "" );
+ static_assert((noexcept(C()) == noexcept(typename C::allocator_type())), "" );
#endif
C c;
LIBCPP_ASSERT(c.__invariants());
@@ -50,9 +50,9 @@
test1(const typename C::allocator_type& a)
{
#if TEST_STD_VER > 14
- static_assert((noexcept(C{typename C::allocator_type{}})), "" );
+ static_assert((noexcept(C{typename C::allocator_type{}})), "" );
#elif TEST_STD_VER >= 11
- static_assert((noexcept(C(typename C::allocator_type())) == std::is_nothrow_copy_constructible<typename C::allocator_type>::value), "" );
+ static_assert((noexcept(C(typename C::allocator_type())) == std::is_nothrow_copy_constructible<typename C::allocator_type>::value), "" );
#endif
C c(a);
LIBCPP_ASSERT(c.__invariants());
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 ec4944d..88613ef 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
@@ -20,40 +20,137 @@
#include "test_allocator.h"
#include "min_allocator.h"
#include "asan_testing.h"
+#if TEST_STD_VER >= 11
+#include "emplace_constructible.h"
+#include "container_test_types.h"
+#endif
template <class C, class Iterator>
-void
-test(Iterator first, Iterator last)
-{
- C c(first, last);
- LIBCPP_ASSERT(c.__invariants());
- assert(c.size() == static_cast<std::size_t>(std::distance(first, last)));
- 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);
+void test(Iterator first, Iterator last) {
+ C c(first, last);
+ LIBCPP_ASSERT(c.__invariants());
+ assert(c.size() == static_cast<std::size_t>(std::distance(first, last)));
+ 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);
}
-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]);
- test<std::vector<int> >(input_iterator<const int*>(a), input_iterator<const int*>(an));
- test<std::vector<int> >(forward_iterator<const int*>(a), forward_iterator<const int*>(an));
- test<std::vector<int> >(bidirectional_iterator<const int*>(a), bidirectional_iterator<const int*>(an));
- test<std::vector<int> >(random_access_iterator<const int*>(a), random_access_iterator<const int*>(an));
- test<std::vector<int> >(a, an);
+static void basic_test_cases() {
+ 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]);
+ test<std::vector<int> >(input_iterator<const int*>(a),
+ input_iterator<const int*>(an));
+ test<std::vector<int> >(forward_iterator<const int*>(a),
+ forward_iterator<const int*>(an));
+ test<std::vector<int> >(bidirectional_iterator<const int*>(a),
+ bidirectional_iterator<const int*>(an));
+ test<std::vector<int> >(random_access_iterator<const int*>(a),
+ random_access_iterator<const int*>(an));
+ test<std::vector<int> >(a, an);
- test<std::vector<int, limited_allocator<int, 63> > >(input_iterator<const int*>(a), input_iterator<const int*>(an));
- // Add 1 for implementations that dynamically allocate a container proxy.
- test<std::vector<int, limited_allocator<int, 18 + 1> > >(forward_iterator<const int*>(a), forward_iterator<const int*>(an));
- test<std::vector<int, limited_allocator<int, 18 + 1> > >(bidirectional_iterator<const int*>(a), bidirectional_iterator<const int*>(an));
- test<std::vector<int, limited_allocator<int, 18 + 1> > >(random_access_iterator<const int*>(a), random_access_iterator<const int*>(an));
- test<std::vector<int, limited_allocator<int, 18 + 1> > >(a, an);
+ test<std::vector<int, limited_allocator<int, 63> > >(
+ input_iterator<const int*>(a), input_iterator<const int*>(an));
+ // Add 1 for implementations that dynamically allocate a container proxy.
+ test<std::vector<int, limited_allocator<int, 18 + 1> > >(
+ forward_iterator<const int*>(a), forward_iterator<const int*>(an));
+ test<std::vector<int, limited_allocator<int, 18 + 1> > >(
+ bidirectional_iterator<const int*>(a),
+ bidirectional_iterator<const int*>(an));
+ test<std::vector<int, limited_allocator<int, 18 + 1> > >(
+ random_access_iterator<const int*>(a),
+ random_access_iterator<const int*>(an));
+ test<std::vector<int, limited_allocator<int, 18 + 1> > >(a, an);
#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));
- test<std::vector<int, min_allocator<int>> >(random_access_iterator<const int*>(a), random_access_iterator<const int*>(an));
- test<std::vector<int> >(a, an);
+ 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));
+ test<std::vector<int, min_allocator<int> > >(
+ random_access_iterator<const int*>(a),
+ random_access_iterator<const int*>(an));
+ test<std::vector<int> >(a, an);
#endif
}
+
+void emplaceable_concept_tests() {
+#if TEST_STD_VER >= 11
+ int arr1[] = {42};
+ int arr2[] = {1, 101, 42};
+ {
+ using T = EmplaceConstructible<int>;
+ using It = forward_iterator<int*>;
+ {
+ std::vector<T> v(It(arr1), It(std::end(arr1)));
+ assert(v[0].value == 42);
+ }
+ {
+ std::vector<T> v(It(arr2), It(std::end(arr2)));
+ assert(v[0].value == 1);
+ assert(v[1].value == 101);
+ assert(v[2].value == 42);
+ }
+ }
+ {
+ using T = EmplaceConstructibleAndMoveInsertable<int>;
+ using It = input_iterator<int*>;
+ {
+ std::vector<T> v(It(arr1), It(std::end(arr1)));
+ assert(v[0].copied == 0);
+ assert(v[0].value == 42);
+ }
+ {
+ std::vector<T> v(It(arr2), It(std::end(arr2)));
+ //assert(v[0].copied == 0);
+ assert(v[0].value == 1);
+ //assert(v[1].copied == 0);
+ assert(v[1].value == 101);
+ assert(v[2].copied == 0);
+ assert(v[2].value == 42);
+ }
+ }
+#endif
+}
+
+void test_ctor_under_alloc() {
+#if TEST_STD_VER >= 11
+ int arr1[] = {42};
+ int arr2[] = {1, 101, 42};
+ {
+ using C = TCT::vector<>;
+ using T = typename C::value_type;
+ using It = forward_iterator<int*>;
+ {
+ ExpectConstructGuard<int&> G(1);
+ C v(It(arr1), It(std::end(arr1)));
+ }
+ {
+ ExpectConstructGuard<int&> G(3);
+ C v(It(arr2), It(std::end(arr2)));
+ }
+ }
+ {
+ using C = TCT::vector<>;
+ using T = typename C::value_type;
+ using It = input_iterator<int*>;
+ {
+ ExpectConstructGuard<int&> G(1);
+ C v(It(arr1), It(std::end(arr1)));
+ }
+ {
+ //ExpectConstructGuard<int&> G(3);
+ //C v(It(arr2), It(std::end(arr2)), a);
+ }
+ }
+#endif
+}
+
+
+int main() {
+ basic_test_cases();
+ emplaceable_concept_tests(); // See PR34898
+ test_ctor_under_alloc();
+}
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 b4482dd..71743b3 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
@@ -21,56 +21,152 @@
#include "test_allocator.h"
#include "min_allocator.h"
#include "asan_testing.h"
+#if TEST_STD_VER >= 11
+#include "emplace_constructible.h"
+#include "container_test_types.h"
+#endif
template <class C, class Iterator, class A>
-void
-test(Iterator first, Iterator last, const A& a)
-{
- C c(first, last, a);
- LIBCPP_ASSERT(c.__invariants());
- assert(c.size() == static_cast<std::size_t>(std::distance(first, last)));
- 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);
+void test(Iterator first, Iterator last, const A& a) {
+ C c(first, last, a);
+ LIBCPP_ASSERT(c.__invariants());
+ assert(c.size() == static_cast<std::size_t>(std::distance(first, last)));
+ 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 TEST_STD_VER >= 11
template <class T>
-struct implicit_conv_allocator : min_allocator<T>
-{
- implicit_conv_allocator(void*) {}
- implicit_conv_allocator(const implicit_conv_allocator&) = default;
+struct implicit_conv_allocator : min_allocator<T> {
+ implicit_conv_allocator(void*) {}
+ implicit_conv_allocator(const implicit_conv_allocator&) = default;
- template <class U>
- implicit_conv_allocator(implicit_conv_allocator<U>) {}
+ template <class U>
+ implicit_conv_allocator(implicit_conv_allocator<U>) {}
};
#endif
-int main()
-{
- {
+void basic_tests() {
+ {
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]);
+ int* an = a + sizeof(a) / sizeof(a[0]);
std::allocator<int> alloc;
- test<std::vector<int> >(input_iterator<const int*>(a), input_iterator<const int*>(an), alloc);
- test<std::vector<int> >(forward_iterator<const int*>(a), forward_iterator<const int*>(an), alloc);
- test<std::vector<int> >(bidirectional_iterator<const int*>(a), bidirectional_iterator<const int*>(an), alloc);
- test<std::vector<int> >(random_access_iterator<const int*>(a), random_access_iterator<const int*>(an), alloc);
+ test<std::vector<int> >(input_iterator<const int*>(a),
+ input_iterator<const int*>(an), alloc);
+ test<std::vector<int> >(forward_iterator<const int*>(a),
+ forward_iterator<const int*>(an), alloc);
+ test<std::vector<int> >(bidirectional_iterator<const int*>(a),
+ bidirectional_iterator<const int*>(an), alloc);
+ 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 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]);
+ int* an = a + sizeof(a) / sizeof(a[0]);
min_allocator<int> alloc;
- test<std::vector<int, min_allocator<int>> >(input_iterator<const int*>(a), input_iterator<const int*>(an), alloc);
- test<std::vector<int, min_allocator<int>> >(forward_iterator<const int*>(a), forward_iterator<const int*>(an), alloc);
- test<std::vector<int, min_allocator<int>> >(bidirectional_iterator<const int*>(a), bidirectional_iterator<const int*>(an), alloc);
- test<std::vector<int, min_allocator<int>> >(random_access_iterator<const int*>(a), random_access_iterator<const int*>(an), alloc);
- test<std::vector<int, min_allocator<int>> >(a, an, alloc);
- test<std::vector<int, implicit_conv_allocator<int>> >(a, an, nullptr);
- }
+ test<std::vector<int, min_allocator<int> > >(
+ input_iterator<const int*>(a), input_iterator<const int*>(an), alloc);
+ test<std::vector<int, min_allocator<int> > >(
+ forward_iterator<const int*>(a), forward_iterator<const int*>(an),
+ alloc);
+ test<std::vector<int, min_allocator<int> > >(
+ bidirectional_iterator<const int*>(a),
+ bidirectional_iterator<const int*>(an), alloc);
+ test<std::vector<int, min_allocator<int> > >(
+ random_access_iterator<const int*>(a),
+ random_access_iterator<const int*>(an), alloc);
+ test<std::vector<int, min_allocator<int> > >(a, an, alloc);
+ test<std::vector<int, implicit_conv_allocator<int> > >(a, an, nullptr);
+ }
#endif
}
+
+void emplaceable_concept_tests() {
+#if TEST_STD_VER >= 11
+ int arr1[] = {42};
+ int arr2[] = {1, 101, 42};
+ {
+ using T = EmplaceConstructible<int>;
+ using It = forward_iterator<int*>;
+ using Alloc = std::allocator<T>;
+ Alloc a;
+ {
+ std::vector<T> v(It(arr1), It(std::end(arr1)), a);
+ assert(v[0].value == 42);
+ }
+ {
+ std::vector<T> v(It(arr2), It(std::end(arr2)), a);
+ assert(v[0].value == 1);
+ assert(v[1].value == 101);
+ assert(v[2].value == 42);
+ }
+ }
+ {
+ using T = EmplaceConstructibleAndMoveInsertable<int>;
+ using It = input_iterator<int*>;
+ using Alloc = std::allocator<T>;
+ Alloc a;
+ {
+ std::vector<T> v(It(arr1), It(std::end(arr1)), a);
+ assert(v[0].copied == 0);
+ assert(v[0].value == 42);
+ }
+ {
+ std::vector<T> v(It(arr2), It(std::end(arr2)), a);
+ assert(v[0].value == 1);
+ assert(v[1].value == 101);
+ assert(v[2].copied == 0);
+ assert(v[2].value == 42);
+ }
+ }
+#endif
+}
+
+void test_ctor_under_alloc() {
+#if TEST_STD_VER >= 11
+ int arr1[] = {42};
+ int arr2[] = {1, 101, 42};
+ {
+ using C = TCT::vector<>;
+ using T = typename C::value_type;
+ using It = forward_iterator<int*>;
+ using Alloc = typename C::allocator_type;
+ Alloc a;
+ {
+ ExpectConstructGuard<int&> G(1);
+ C v(It(arr1), It(std::end(arr1)), a);
+ }
+ {
+ ExpectConstructGuard<int&> G(3);
+ C v(It(arr2), It(std::end(arr2)), a);
+ }
+ }
+ {
+ using C = TCT::vector<>;
+ using T = typename C::value_type;
+ using It = input_iterator<int*>;
+ using Alloc = typename C::allocator_type;
+ Alloc a;
+ {
+ ExpectConstructGuard<int&> G(1);
+ C v(It(arr1), It(std::end(arr1)), a);
+ }
+ {
+ //ExpectConstructGuard<int&> G(3);
+ //C v(It(arr2), It(std::end(arr2)), a);
+ }
+ }
+#endif
+}
+
+int main() {
+ basic_tests();
+ emplaceable_concept_tests(); // See PR34898
+ test_ctor_under_alloc();
+}
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 b7ea3a2..0fc335f 100644
--- a/test/std/containers/sequences/vector/vector.data/data.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.data/data.pass.cpp
@@ -18,13 +18,13 @@
#include "asan_testing.h"
struct Nasty {
- Nasty() : i_(0) {}
- Nasty(int i) : i_(i) {}
- ~Nasty() {}
+ Nasty() : i_(0) {}
+ Nasty(int i) : i_(i) {}
+ ~Nasty() {}
- Nasty * operator&() const { assert(false); return nullptr; }
- int i_;
- };
+ Nasty * operator&() const { assert(false); return nullptr; }
+ int i_;
+ };
int main()
{
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 3c013c1..fa8b6a8 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
@@ -18,13 +18,13 @@
#include "asan_testing.h"
struct Nasty {
- Nasty() : i_(0) {}
- Nasty(int i) : i_(i) {}
- ~Nasty() {}
+ Nasty() : i_(0) {}
+ Nasty(int i) : i_(i) {}
+ ~Nasty() {}
- Nasty * operator&() const { assert(false); return nullptr; }
- int i_;
- };
+ Nasty * operator&() const { assert(false); return nullptr; }
+ int i_;
+ };
int main()
{
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 f92ab8a..062ee22 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
@@ -73,7 +73,7 @@
{
typedef std::vector<MoveOnly, some_alloc<MoveOnly>> C;
#if TEST_STD_VER >= 14
- // In c++14, if POCS is set, swapping the allocator is required not to throw
+ // In C++14, if POCS is set, swapping the allocator is required not to throw
static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
#else
static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
diff --git a/test/std/containers/unord/unord.map/rehash.pass.cpp b/test/std/containers/unord/unord.map/rehash.pass.cpp
index 58222b7..4101572 100644
--- a/test/std/containers/unord/unord.map/rehash.pass.cpp
+++ b/test/std/containers/unord/unord.map/rehash.pass.cpp
@@ -25,7 +25,7 @@
template <class C>
void rehash_postcondition(const C& c, size_t n)
{
- assert(c.bucket_count() >= c.size() / c.max_load_factor() && c.bucket_count() >= n);
+ assert(c.bucket_count() >= c.size() / c.max_load_factor() && c.bucket_count() >= n);
}
template <class C>
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
index 7f62a4f..8f6f16c 100644
--- 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
@@ -19,14 +19,14 @@
template <class T>
struct Comp {
- bool operator () (const T& lhs, const T& rhs) const { return lhs == rhs; }
+ bool operator () (const T& lhs, const T& rhs) const { return lhs == rhs; }
- Comp () {}
+ Comp () {}
private:
- Comp (const Comp &); // declared but not defined
- };
+ Comp (const Comp &); // declared but not defined
+ };
int main() {
- std::unordered_map<int, int, std::hash<int>, Comp<int> > m;
+ std::unordered_map<int, int, std::hash<int>, Comp<int> > m;
}
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
index 2525c44..aca2a5a 100644
--- 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
@@ -19,14 +19,14 @@
template <class T>
struct Hash {
- std::size_t operator () (const T& lhs) const { return 0; }
+ std::size_t operator () (const T& lhs) const { return 0; }
- Hash () {}
+ Hash () {}
private:
- Hash (const Hash &); // declared but not defined
+ Hash (const Hash &); // declared but not defined
};
int main() {
- std::unordered_map<int, int, Hash<int> > m;
+ std::unordered_map<int, int, Hash<int> > m;
}
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_or_assign.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_or_assign.pass.cpp
index a4d8abc..e84301e 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_or_assign.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_or_assign.pass.cpp
@@ -189,4 +189,4 @@
assert(r->second.get() == 5); // value
}
-}
\ No newline at end of file
+}
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 75807fa..9497b15 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
@@ -122,7 +122,7 @@
int main()
{
- typedef std::pair<const MoveOnly, MoveOnly> MapType;
+ typedef std::pair<const MoveOnly, MoveOnly> MapType;
{
typedef std::unordered_map<MoveOnly, MoveOnly> C;
static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
diff --git a/test/std/containers/unord/unord.multimap/rehash.pass.cpp b/test/std/containers/unord/unord.multimap/rehash.pass.cpp
index 3d3832a..22202cc 100644
--- a/test/std/containers/unord/unord.multimap/rehash.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/rehash.pass.cpp
@@ -28,7 +28,7 @@
template <class C>
void rehash_postcondition(const C& c, size_t n)
{
- assert(c.bucket_count() >= c.size() / c.max_load_factor() && c.bucket_count() >= n);
+ assert(c.bucket_count() >= c.size() / c.max_load_factor() && c.bucket_count() >= n);
}
template <class C>
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
index 1c46e7a..cb0ce52 100644
--- 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
@@ -19,14 +19,14 @@
template <class T>
struct Comp {
- bool operator () (const T& lhs, const T& rhs) const { return lhs == rhs; }
+ bool operator () (const T& lhs, const T& rhs) const { return lhs == rhs; }
- Comp () {}
+ Comp () {}
private:
- Comp (const Comp &); // declared but not defined
- };
+ Comp (const Comp &); // declared but not defined
+ };
int main() {
- std::unordered_multimap<int, int, std::hash<int>, Comp<int> > m;
+ std::unordered_multimap<int, int, std::hash<int>, Comp<int> > m;
}
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
index 71e1c9f..f5f42e5 100644
--- 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
@@ -19,14 +19,14 @@
template <class T>
struct Hash {
- std::size_t operator () (const T& lhs) const { return 0; }
+ std::size_t operator () (const T& lhs) const { return 0; }
- Hash () {}
+ Hash () {}
private:
- Hash (const Hash &); // declared but not defined
- };
+ Hash (const Hash &); // declared but not defined
+ };
int main() {
- std::unordered_multimap<int, int, Hash<int> > m;
+ std::unordered_multimap<int, int, Hash<int> > m;
}
diff --git a/test/std/containers/unord/unord.multiset/rehash.pass.cpp b/test/std/containers/unord/unord.multiset/rehash.pass.cpp
index 2c5d509..83fb58d 100644
--- a/test/std/containers/unord/unord.multiset/rehash.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/rehash.pass.cpp
@@ -24,7 +24,7 @@
template <class C>
void rehash_postcondition(const C& c, size_t n)
{
- assert(c.bucket_count() >= c.size() / c.max_load_factor() && c.bucket_count() >= n);
+ assert(c.bucket_count() >= c.size() / c.max_load_factor() && c.bucket_count() >= n);
}
template <class C>
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
index 1cda95b..1b81905 100644
--- 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
@@ -16,14 +16,14 @@
template <class T>
struct Comp {
- bool operator () (const T& lhs, const T& rhs) const { return lhs == rhs; }
+ bool operator () (const T& lhs, const T& rhs) const { return lhs == rhs; }
- Comp () {}
+ Comp () {}
private:
- Comp (const Comp &); // declared but not defined
- };
+ Comp (const Comp &); // declared but not defined
+ };
int main() {
- std::unordered_multiset<int, std::hash<int>, Comp<int> > m;
+ std::unordered_multiset<int, std::hash<int>, Comp<int> > m;
}
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
index 6fa52a7..cae8ab9 100644
--- 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
@@ -16,14 +16,14 @@
template <class T>
struct Hash {
- std::size_t operator () (const T& lhs) const { return 0; }
+ std::size_t operator () (const T& lhs) const { return 0; }
- Hash () {}
+ Hash () {}
private:
- Hash (const Hash &); // declared but not defined
- };
+ Hash (const Hash &); // declared but not defined
+ };
int main() {
- std::unordered_multiset<int, Hash<int> > m;
+ std::unordered_multiset<int, Hash<int> > m;
}
diff --git a/test/std/containers/unord/unord.set/rehash.pass.cpp b/test/std/containers/unord/unord.set/rehash.pass.cpp
index fd689bf..dc3adcc 100644
--- a/test/std/containers/unord/unord.set/rehash.pass.cpp
+++ b/test/std/containers/unord/unord.set/rehash.pass.cpp
@@ -24,7 +24,7 @@
template <class C>
void rehash_postcondition(const C& c, size_t n)
{
- assert(c.bucket_count() >= c.size() / c.max_load_factor() && c.bucket_count() >= n);
+ assert(c.bucket_count() >= c.size() / c.max_load_factor() && c.bucket_count() >= n);
}
template <class C>
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
index 7978255..4117314 100644
--- 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
@@ -16,14 +16,14 @@
template <class T>
struct Comp {
- bool operator () (const T& lhs, const T& rhs) const { return lhs == rhs; }
+ bool operator () (const T& lhs, const T& rhs) const { return lhs == rhs; }
- Comp () {}
+ Comp () {}
private:
- Comp (const Comp &); // declared but not defined
- };
+ Comp (const Comp &); // declared but not defined
+ };
int main() {
- std::unordered_set<int, std::hash<int>, Comp<int> > m;
+ std::unordered_set<int, std::hash<int>, Comp<int> > m;
}
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 81ad16b..caa4bef 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
@@ -82,7 +82,7 @@
assert(c.max_load_factor() == 1);
}
{
- A a;
+ A a;
C c(a);
LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
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
index 9e135e2..da368a1 100644
--- 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
@@ -16,14 +16,14 @@
template <class T>
struct Hash {
- std::size_t operator () (const T& lhs) const { return 0; }
+ std::size_t operator () (const T& lhs) const { return 0; }
- Hash () {}
+ Hash () {}
private:
- Hash (const Hash &); // declared but not defined
- };
+ Hash (const Hash &); // declared but not defined
+ };
int main() {
- std::unordered_set<int, Hash<int> > m;
+ std::unordered_set<int, Hash<int> > m;
}
diff --git a/test/std/depr/depr.c.headers/complex.h.pass.cpp b/test/std/depr/depr.c.headers/complex.h.pass.cpp
index 0e3fd3e..4effd96 100644
--- a/test/std/depr/depr.c.headers/complex.h.pass.cpp
+++ b/test/std/depr/depr.c.headers/complex.h.pass.cpp
@@ -14,4 +14,5 @@
int main()
{
std::complex<double> d;
+ (void)d;
}
diff --git a/test/std/depr/depr.c.headers/tgmath_h.pass.cpp b/test/std/depr/depr.c.headers/tgmath_h.pass.cpp
index 965a8de..91727b6 100644
--- a/test/std/depr/depr.c.headers/tgmath_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/tgmath_h.pass.cpp
@@ -14,6 +14,7 @@
int main()
{
std::complex<double> cd;
+ (void)cd;
double x = sin(1.0);
(void)x; // to placate scan-build
}
diff --git a/test/std/depr/depr.c.headers/uchar_h.pass.cpp b/test/std/depr/depr.c.headers/uchar_h.pass.cpp
index f5f69f8..f121698 100644
--- a/test/std/depr/depr.c.headers/uchar_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/uchar_h.pass.cpp
@@ -7,6 +7,7 @@
//
//===----------------------------------------------------------------------===//
//
+// XFAIL: suse-linux-enterprise-server-11
// XFAIL: apple-darwin
// XFAIL: newlib
diff --git a/test/std/depr/depr.function.objects/depr.base/binary_function.pass.cpp b/test/std/depr/depr.function.objects/depr.base/binary_function.pass.cpp
index ddca8fd..0ae3b00 100644
--- a/test/std/depr/depr.function.objects/depr.base/binary_function.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.base/binary_function.pass.cpp
@@ -8,6 +8,8 @@
//===----------------------------------------------------------------------===//
// <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
+// binary_function was removed in C++17
// template <class Arg1, class Arg2, class Result>
// struct binary_function
diff --git a/test/std/depr/depr.function.objects/depr.base/unary_function.pass.cpp b/test/std/depr/depr.function.objects/depr.base/unary_function.pass.cpp
index 87cfe09..ededc53 100644
--- a/test/std/depr/depr.function.objects/depr.base/unary_function.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.base/unary_function.pass.cpp
@@ -8,6 +8,8 @@
//===----------------------------------------------------------------------===//
// <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
+// unary_function was removed in C++17
// template <class Arg, class Result>
// struct unary_function
diff --git a/test/std/diagnostics/syserr/is_error_code_enum.pass.cpp b/test/std/diagnostics/syserr/is_error_code_enum.pass.cpp
index bd84362..a74bd2f 100644
--- a/test/std/diagnostics/syserr/is_error_code_enum.pass.cpp
+++ b/test/std/diagnostics/syserr/is_error_code_enum.pass.cpp
@@ -28,8 +28,8 @@
}
class A {
- A();
- operator std::error_code () const { return std::error_code(); }
+ A();
+ operator std::error_code () const { return std::error_code(); }
};
// Specialize the template for my class
diff --git a/test/std/diagnostics/syserr/is_error_condition_enum.pass.cpp b/test/std/diagnostics/syserr/is_error_condition_enum.pass.cpp
index b2efd9e..1321dcc 100644
--- a/test/std/diagnostics/syserr/is_error_condition_enum.pass.cpp
+++ b/test/std/diagnostics/syserr/is_error_condition_enum.pass.cpp
@@ -28,8 +28,8 @@
}
class A {
- A();
- operator std::error_condition () const { return std::error_condition(); }
+ A();
+ operator std::error_condition () const { return std::error_condition(); }
};
// Specialize the template for my class
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 0783de8..cd76a9f 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
@@ -7,6 +7,7 @@
//
//===----------------------------------------------------------------------===//
+// XFAIL: suse-linux-enterprise-server-11
// XFAIL: with_system_cxx_lib=macosx10.12
// XFAIL: with_system_cxx_lib=macosx10.11
// XFAIL: with_system_cxx_lib=macosx10.10
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 8cccb02..c9c6d52 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
@@ -13,6 +13,7 @@
// const error_category& system_category();
+// XFAIL: suse-linux-enterprise-server-11
// XFAIL: with_system_cxx_lib=macosx10.12
// XFAIL: with_system_cxx_lib=macosx10.11
// XFAIL: with_system_cxx_lib=macosx10.10
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.overview/types.pass.cpp b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.overview/types.pass.cpp
new file mode 100644
index 0000000..a2515a4
--- /dev/null
+++ b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.overview/types.pass.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <system_error>
+// class error_code
+
+// Make sure that the error_code bits of <system_error> are self-contained.
+
+#include <system_error>
+
+int main()
+{
+ std::error_code x;
+ (void) x.category(); // returns a std::error_category &
+ (void) x.default_error_condition(); // std::error_condition
+ (void) x.message(); // returns a std::string
+}
diff --git a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.overview/nothing_to_do.pass.cpp b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.overview/nothing_to_do.pass.cpp
deleted file mode 100644
index b58f5c5..0000000
--- a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.overview/nothing_to_do.pass.cpp
+++ /dev/null
@@ -1,12 +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.
-//
-//===----------------------------------------------------------------------===//
-
-int main()
-{
-}
diff --git a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.overview/types.pass.cpp b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.overview/types.pass.cpp
new file mode 100644
index 0000000..5bbca29
--- /dev/null
+++ b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.overview/types.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <system_error>
+// class error_condition
+
+// Make sure that the error_condition bits of <system_error> are self-contained.
+
+#include <system_error>
+
+int main()
+{
+ std::error_condition x = std::errc(0);
+ (void) x.category(); // returns a std::error_condition &
+ (void) x.message(); // returns a std::string
+}
diff --git a/test/std/experimental/algorithms/alg.search/search.pass.cpp b/test/std/experimental/algorithms/alg.search/search.pass.cpp
index 81d220b..126f7c8 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).first
+// returns searcher.operator(first, last).first
//
#include <experimental/algorithm>
diff --git a/test/std/experimental/any/any.class/any.assign/copy.pass.cpp b/test/std/experimental/any/any.class/any.assign/copy.pass.cpp
index 7140fab..0b9d71e 100644
--- a/test/std/experimental/any/any.class/any.assign/copy.pass.cpp
+++ b/test/std/experimental/any/any.class/any.assign/copy.pass.cpp
@@ -9,12 +9,7 @@
// UNSUPPORTED: c++98, c++03, c++11
-// XFAIL: with_system_cxx_lib=macosx10.12
-// XFAIL: with_system_cxx_lib=macosx10.11
-// XFAIL: with_system_cxx_lib=macosx10.10
-// XFAIL: with_system_cxx_lib=macosx10.9
-// XFAIL: with_system_cxx_lib=macosx10.7
-// XFAIL: with_system_cxx_lib=macosx10.8
+// XFAIL: availability=macosx
// <experimental/any>
diff --git a/test/std/experimental/any/any.class/any.assign/move.pass.cpp b/test/std/experimental/any/any.class/any.assign/move.pass.cpp
index 35fc56c..72351ae 100644
--- a/test/std/experimental/any/any.class/any.assign/move.pass.cpp
+++ b/test/std/experimental/any/any.class/any.assign/move.pass.cpp
@@ -9,12 +9,7 @@
// UNSUPPORTED: c++98, c++03, c++11
-// XFAIL: with_system_cxx_lib=macosx10.12
-// XFAIL: with_system_cxx_lib=macosx10.11
-// XFAIL: with_system_cxx_lib=macosx10.10
-// XFAIL: with_system_cxx_lib=macosx10.9
-// XFAIL: with_system_cxx_lib=macosx10.7
-// XFAIL: with_system_cxx_lib=macosx10.8
+// XFAIL: availability=macosx
// <experimental/any>
diff --git a/test/std/experimental/any/any.class/any.assign/value.pass.cpp b/test/std/experimental/any/any.class/any.assign/value.pass.cpp
index 8ff4ad5..cd4646f 100644
--- a/test/std/experimental/any/any.class/any.assign/value.pass.cpp
+++ b/test/std/experimental/any/any.class/any.assign/value.pass.cpp
@@ -9,12 +9,7 @@
// UNSUPPORTED: c++98, c++03, c++11
-// XFAIL: with_system_cxx_lib=macosx10.12
-// XFAIL: with_system_cxx_lib=macosx10.11
-// XFAIL: with_system_cxx_lib=macosx10.10
-// XFAIL: with_system_cxx_lib=macosx10.9
-// XFAIL: with_system_cxx_lib=macosx10.7
-// XFAIL: with_system_cxx_lib=macosx10.8
+// XFAIL: availability=macosx
// <experimental/any>
diff --git a/test/std/experimental/any/any.class/any.assign/value_non_copyable_assign.fail.cpp b/test/std/experimental/any/any.class/any.assign/value_non_copyable_assign.fail.cpp
index ce0d44f..7d2d33d 100644
--- a/test/std/experimental/any/any.class/any.assign/value_non_copyable_assign.fail.cpp
+++ b/test/std/experimental/any/any.class/any.assign/value_non_copyable_assign.fail.cpp
@@ -32,7 +32,7 @@
using namespace std::experimental;
non_copyable nc;
any a;
- a = static_cast<non_copyable &&>(nc); // expected-error@experimental/any:* 2 {{static_assert failed "_ValueType must be CopyConstructible."}}
+ a = static_cast<non_copyable &&>(nc); // expected-error-re@experimental/any:* 2 {{static_assert failed{{.*}} "_ValueType must be CopyConstructible."}}
// expected-error@experimental/any:* {{calling a private constructor of class 'non_copyable'}}
}
diff --git a/test/std/experimental/any/any.class/any.cons/copy.pass.cpp b/test/std/experimental/any/any.class/any.cons/copy.pass.cpp
index 47f12d7..d477394 100644
--- a/test/std/experimental/any/any.class/any.cons/copy.pass.cpp
+++ b/test/std/experimental/any/any.class/any.cons/copy.pass.cpp
@@ -9,12 +9,7 @@
// UNSUPPORTED: c++98, c++03, c++11
-// XFAIL: with_system_cxx_lib=macosx10.12
-// XFAIL: with_system_cxx_lib=macosx10.11
-// XFAIL: with_system_cxx_lib=macosx10.10
-// XFAIL: with_system_cxx_lib=macosx10.9
-// XFAIL: with_system_cxx_lib=macosx10.7
-// XFAIL: with_system_cxx_lib=macosx10.8
+// XFAIL: availability=macosx
// <experimental/any>
diff --git a/test/std/experimental/any/any.class/any.cons/move.pass.cpp b/test/std/experimental/any/any.class/any.cons/move.pass.cpp
index c5395da..ef980ca 100644
--- a/test/std/experimental/any/any.class/any.cons/move.pass.cpp
+++ b/test/std/experimental/any/any.class/any.cons/move.pass.cpp
@@ -9,12 +9,7 @@
// UNSUPPORTED: c++98, c++03, c++11
-// XFAIL: with_system_cxx_lib=macosx10.12
-// XFAIL: with_system_cxx_lib=macosx10.11
-// XFAIL: with_system_cxx_lib=macosx10.10
-// XFAIL: with_system_cxx_lib=macosx10.9
-// XFAIL: with_system_cxx_lib=macosx10.7
-// XFAIL: with_system_cxx_lib=macosx10.8
+// XFAIL: availability=macosx
// <experimental/any>
diff --git a/test/std/experimental/any/any.class/any.cons/non_copyable_value.fail.cpp b/test/std/experimental/any/any.class/any.cons/non_copyable_value.fail.cpp
index 643b962..c4f7568 100644
--- a/test/std/experimental/any/any.class/any.cons/non_copyable_value.fail.cpp
+++ b/test/std/experimental/any/any.class/any.cons/non_copyable_value.fail.cpp
@@ -31,6 +31,6 @@
using namespace std::experimental;
non_copyable nc;
any a(static_cast<non_copyable &&>(nc));
- // expected-error@experimental/any:* 1 {{static_assert failed "_ValueType must be CopyConstructible."}}
+ // expected-error-re@experimental/any:* 1 {{static_assert failed{{.*}} "_ValueType must be CopyConstructible."}}
// expected-error@experimental/any:* 1 {{calling a private constructor of class 'non_copyable'}}
}
diff --git a/test/std/experimental/any/any.class/any.cons/value.pass.cpp b/test/std/experimental/any/any.class/any.cons/value.pass.cpp
index fcace50..d37990e 100644
--- a/test/std/experimental/any/any.class/any.cons/value.pass.cpp
+++ b/test/std/experimental/any/any.class/any.cons/value.pass.cpp
@@ -9,12 +9,7 @@
// UNSUPPORTED: c++98, c++03, c++11
-// XFAIL: with_system_cxx_lib=macosx10.12
-// XFAIL: with_system_cxx_lib=macosx10.11
-// XFAIL: with_system_cxx_lib=macosx10.10
-// XFAIL: with_system_cxx_lib=macosx10.9
-// XFAIL: with_system_cxx_lib=macosx10.7
-// XFAIL: with_system_cxx_lib=macosx10.8
+// XFAIL: availability=macosx
// <experimental/any>
diff --git a/test/std/experimental/any/any.class/any.modifiers/clear.pass.cpp b/test/std/experimental/any/any.class/any.modifiers/clear.pass.cpp
index 1b0b75d..a19bd38 100644
--- a/test/std/experimental/any/any.class/any.modifiers/clear.pass.cpp
+++ b/test/std/experimental/any/any.class/any.modifiers/clear.pass.cpp
@@ -9,12 +9,7 @@
// UNSUPPORTED: c++98, c++03, c++11
-// XFAIL: with_system_cxx_lib=macosx10.12
-// XFAIL: with_system_cxx_lib=macosx10.11
-// XFAIL: with_system_cxx_lib=macosx10.10
-// XFAIL: with_system_cxx_lib=macosx10.9
-// XFAIL: with_system_cxx_lib=macosx10.7
-// XFAIL: with_system_cxx_lib=macosx10.8
+// XFAIL: availability=macosx
// <experimental/any>
diff --git a/test/std/experimental/any/any.class/any.modifiers/swap.pass.cpp b/test/std/experimental/any/any.class/any.modifiers/swap.pass.cpp
index 9f499b4..8de582a 100644
--- a/test/std/experimental/any/any.class/any.modifiers/swap.pass.cpp
+++ b/test/std/experimental/any/any.class/any.modifiers/swap.pass.cpp
@@ -9,12 +9,7 @@
// UNSUPPORTED: c++98, c++03, c++11
-// XFAIL: with_system_cxx_lib=macosx10.12
-// XFAIL: with_system_cxx_lib=macosx10.11
-// XFAIL: with_system_cxx_lib=macosx10.10
-// XFAIL: with_system_cxx_lib=macosx10.9
-// XFAIL: with_system_cxx_lib=macosx10.7
-// XFAIL: with_system_cxx_lib=macosx10.8
+// XFAIL: availability=macosx
// <experimental/any>
diff --git a/test/std/experimental/any/any.nonmembers/any.cast/reference_types.fail.cpp b/test/std/experimental/any/any.nonmembers/any.cast/reference_types.fail.cpp
index 6c6ccc6..edef3d0 100644
--- a/test/std/experimental/any/any.nonmembers/any.cast/reference_types.fail.cpp
+++ b/test/std/experimental/any/any.nonmembers/any.cast/reference_types.fail.cpp
@@ -25,13 +25,13 @@
int main()
{
any a(1);
- any_cast<int &>(&a); // expected-error@experimental/any:* 1 {{static_assert failed "_ValueType may not be a reference."}}
- any_cast<int &&>(&a); // expected-error@experimental/any:* 1 {{static_assert failed "_ValueType may not be a reference."}}
- any_cast<int const &>(&a); // expected-error@experimental/any:* 1 {{static_assert failed "_ValueType may not be a reference."}}
- any_cast<int const&&>(&a); // expected-error@experimental/any:* 1 {{static_assert failed "_ValueType may not be a reference."}}
+ any_cast<int &>(&a); // expected-error-re@experimental/any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
+ any_cast<int &&>(&a); // expected-error-re@experimental/any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
+ any_cast<int const &>(&a); // expected-error-re@experimental/any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
+ any_cast<int const&&>(&a); // expected-error-re@experimental/any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
any const& a2 = a;
- any_cast<int &>(&a2); // expected-error@experimental/any:* 1 {{static_assert failed "_ValueType may not be a reference."}}
- any_cast<int &&>(&a2); // expected-error@experimental/any:* 1 {{static_assert failed "_ValueType may not be a reference."}}
- any_cast<int const &>(&a2); // expected-error@experimental/any:* 1 {{static_assert failed "_ValueType may not be a reference."}}
- any_cast<int const &&>(&a2); // expected-error@experimental/any:* 1 {{static_assert failed "_ValueType may not be a reference."}}
+ any_cast<int &>(&a2); // expected-error-re@experimental/any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
+ any_cast<int &&>(&a2); // expected-error-re@experimental/any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
+ any_cast<int const &>(&a2); // expected-error-re@experimental/any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
+ any_cast<int const &&>(&a2); // expected-error-re@experimental/any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
}
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
index 621ff83..a3591e0 100644
--- 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
@@ -26,63 +26,87 @@
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(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_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_reports_error_if_input_dne) {
+ const path E = StaticEnv::File;
+ const path DNE = StaticEnv::DNE;
+ { // Test that an error is reported when either of the paths don't exist
+ std::error_code ec = GetTestEC();
+ TEST_CHECK(equivalent(E, DNE, ec) == false);
+ TEST_CHECK(ec);
+ TEST_CHECK(ec != GetTestEC());
+ }
+ {
+ std::error_code ec = GetTestEC();
+ TEST_CHECK(equivalent(DNE, E, ec) == false);
+ TEST_CHECK(ec);
+ TEST_CHECK(ec != GetTestEC());
+ }
+ {
+ TEST_CHECK_THROW(filesystem_error, equivalent(DNE, E));
+ TEST_CHECK_THROW(filesystem_error, equivalent(E, DNE));
+ }
+ { // Test that an exception is thrown if both paths do not exist.
+ TEST_CHECK_THROW(filesystem_error, equivalent(DNE, DNE));
+ }
+ {
+ std::error_code ec = GetTestEC();
+ TEST_CHECK(equivalent(DNE, DNE, ec) == false);
+ TEST_CHECK(ec);
+ TEST_CHECK(ec != GetTestEC());
+ }
}
-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_CASE(equivalent_hardlink_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_CASE(equivalent_is_other_succeeds) {
+ scoped_test_env env;
+ path const file = env.create_file("file", 42);
+ const path fifo1 = env.create_fifo("fifo1");
+ const path fifo2 = env.create_fifo("fifo2");
+ // Required to test behavior for inputs where is_other(p) is true.
+ TEST_REQUIRE(is_other(fifo1));
+ TEST_CHECK(!equivalent(file, fifo1));
+ TEST_CHECK(!equivalent(fifo2, file));
+ TEST_CHECK(!equivalent(fifo1, fifo2));
+ TEST_CHECK(equivalent(fifo1, fifo1));
}
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
index ed25649..cdd1773 100644
--- 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
@@ -88,6 +88,16 @@
return !ec && new_write_time <= -5;
}
+// In some configurations, the comparison is tautological and the test is valid.
+// We disable the warning so that we can actually test it regardless. Also, that
+// diagnostic is pretty new, so also don't fail if old clang does not support it
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunknown-warning-option"
+#pragma clang diagnostic ignored "-Wunknown-pragmas"
+#pragma clang diagnostic ignored "-Wtautological-constant-compare"
+#endif
+
bool TestSupportsMaxTime() {
using namespace std::chrono;
using Lim = std::numeric_limits<std::time_t>;
@@ -106,11 +116,25 @@
return !ec && new_write_time > max_sec - 1;
}
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
static const bool SupportsNegativeTimes = TestSupportsNegativeTimes();
static const bool SupportsMaxTime = TestSupportsMaxTime();
} // end namespace
+// In some configurations, the comparison is tautological and the test is valid.
+// We disable the warning so that we can actually test it regardless. Also, that
+// diagnostic is pretty new, so also don't fail if old clang does not support it
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunknown-warning-option"
+#pragma clang diagnostic ignored "-Wunknown-pragmas"
+#pragma clang diagnostic ignored "-Wtautological-constant-compare"
+#endif
+
// Check if a time point is representable on a given filesystem. Check that:
// (A) 'tp' is representable as a time_t
// (B) 'tp' is non-negative or the filesystem supports negative times.
@@ -127,6 +151,10 @@
return true;
}
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
TEST_SUITE(exists_test_suite)
TEST_CASE(signature_test)
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 467e09d..68c786b 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
@@ -39,7 +39,7 @@
#include "test_iterators.h"
template <typename T> struct MyHash {
- size_t operator () (T t) const { return static_cast<size_t>(t); }
+ size_t operator () (T t) const { return static_cast<size_t>(t); }
};
template <typename Iter1, typename Iter2>
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 b0e5e87..fe03fa0 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
@@ -39,7 +39,7 @@
#include "test_iterators.h"
template <typename T> struct MyHash {
- size_t operator () (T t) const { return static_cast<size_t>(t); }
+ size_t operator () (T t) const { return static_cast<size_t>(t); }
};
struct count_equal
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 abfab17..e2d34df 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
@@ -38,7 +38,7 @@
#include "test_iterators.h"
template <typename T> struct MyHash {
- size_t operator () (T t) const { return static_cast<size_t>(t); }
+ size_t operator () (T t) const { return static_cast<size_t>(t); }
};
template <typename Iter1, typename Iter2>
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 28f3324..eaa5233 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
@@ -38,7 +38,7 @@
#include "test_iterators.h"
template <typename T> struct MyHash {
- size_t operator () (T t) const { return static_cast<size_t>(t); }
+ size_t operator () (T t) const { return static_cast<size_t>(t); }
};
struct count_equal
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
index 5c84d21..0bae57e 100644
--- 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
@@ -26,33 +26,33 @@
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;
+ 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/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); }
+// 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/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); }
+// 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.ops/ostream_joiner.op.assign.pass.cpp b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.assign.pass.cpp
index b2c294f..87ab1e2 100644
--- 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
@@ -27,10 +27,10 @@
#include "test_iterators.h"
struct mutating_delimiter {
- mutating_delimiter(char c = ' ') : c_(c) {}
- char get () const { return c_++; }
- mutable char c_;
- };
+ mutating_delimiter(char c = ' ') : c_(c) {}
+ char get () const { return c_++; }
+ mutable char c_;
+ };
template<class _CharT, class _Traits>
std::basic_ostream<_CharT, _Traits>&
@@ -39,10 +39,10 @@
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_;
- };
+ mutating_delimiter2(char c = ' ') : c_(c) {}
+ char get () { return c_++; }
+ char c_;
+ };
template<class _CharT, class _Traits>
std::basic_ostream<_CharT, _Traits>&
@@ -54,67 +54,67 @@
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;
+ 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), "" );
+ 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);
- }
+ 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 };
+ 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('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("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<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");
- }
+ 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");
+ {
+ 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(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<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");
- }
+ test(mutating_delimiter(), chars, chars+10, L"0 1!2\"3#4$5%6&7'8(9");
+ }
}
diff --git a/test/std/experimental/language.support/support.coroutines/end.to.end/fullexpr-dtor.pass.cpp b/test/std/experimental/language.support/support.coroutines/end.to.end/fullexpr-dtor.pass.cpp
index 20bcf60..83c9da6 100644
--- a/test/std/experimental/language.support/support.coroutines/end.to.end/fullexpr-dtor.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/end.to.end/fullexpr-dtor.pass.cpp
@@ -33,7 +33,7 @@
Noisy(Noisy const&) = delete;
#else
// FIXME: This test depends on copy elision taking place in C++14
- // (pre-c++17 guaranteed copy elision)
+ // (pre-C++17 guaranteed copy elision)
Noisy(Noisy const&);
#endif
};
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
index eddfede..8cce9d2 100644
--- 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
@@ -24,4 +24,4 @@
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/numeric/numeric.ops/numeric.ops.lcm/lcm.pass.cpp b/test/std/experimental/numeric/numeric.ops/numeric.ops.lcm/lcm.pass.cpp
index fd463e8..211363a 100644
--- a/test/std/experimental/numeric/numeric.ops/numeric.ops.lcm/lcm.pass.cpp
+++ b/test/std/experimental/numeric/numeric.ops/numeric.ops.lcm/lcm.pass.cpp
@@ -132,8 +132,8 @@
// LWG#2792
{
auto res1 = std::experimental::lcm((int64_t)1234, (int32_t)-2147483648);
- (void) std::experimental::lcm<int, unsigned long>(INT_MIN, 2); // this used to trigger UBSAN
+ (void) std::experimental::lcm<int, unsigned long>(INT_MIN, 2); // this used to trigger UBSAN
static_assert( std::is_same<decltype(res1), std::common_type<int64_t, int32_t>::type>::value, "");
- assert(res1 == 1324997410816LL);
+ assert(res1 == 1324997410816LL);
}
}
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 8cf11b5..b8fba47 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
@@ -19,4 +19,5 @@
using std::experimental::optional;
std::initializer_list<int> list;
+ (void)list;
}
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 b2ffa61..72e9dad 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
@@ -29,4 +29,4 @@
assert ( sv1.size() == s.size());
assert ( sv1.data() == s.data());
}
-}
\ No newline at end of file
+}
diff --git a/test/std/experimental/utilities/tuple/header.tuple.synop/includes.pass.cpp b/test/std/experimental/utilities/tuple/header.tuple.synop/includes.pass.cpp
index d37557a..5cfb15e 100644
--- a/test/std/experimental/utilities/tuple/header.tuple.synop/includes.pass.cpp
+++ b/test/std/experimental/utilities/tuple/header.tuple.synop/includes.pass.cpp
@@ -16,4 +16,5 @@
int main()
{
std::tuple<int> x(1);
+ (void)x;
}
diff --git a/test/std/input.output/iostream.format/ext.manip/put_money.pass.cpp b/test/std/input.output/iostream.format/ext.manip/put_money.pass.cpp
index a00cf13..342e337 100644
--- a/test/std/input.output/iostream.format/ext.manip/put_money.pass.cpp
+++ b/test/std/input.output/iostream.format/ext.manip/put_money.pass.cpp
@@ -35,18 +35,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = str_.size();
- str_.push_back(__c);
+ str_.push_back(static_cast<CharT>(ch));
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
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 d12b91c..dae74f0 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
@@ -35,18 +35,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(static_cast<CharT>(__c));
+ str_.push_back(static_cast<CharT>(ch));
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/streambuf.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/streambuf.pass.cpp
index 29ed68e..6b6737a 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/streambuf.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/streambuf.pass.cpp
@@ -41,18 +41,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = str_.size();
- str_.push_back(__c);
+ str_.push_back(static_cast<CharT>(ch));
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf.pass.cpp
index e732729..0a48393 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf.pass.cpp
@@ -38,18 +38,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(static_cast<CharT>(__c));
+ str_.push_back(static_cast<CharT>(ch));
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf_chart.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf_chart.pass.cpp
index 292cf7c..c6368b4 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf_chart.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf_chart.pass.cpp
@@ -39,18 +39,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(static_cast<CharT>(__c));
+ str_.push_back(static_cast<CharT>(ch));
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/bool.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/bool.pass.cpp
index fe038a7..00332f7 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/bool.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/bool.pass.cpp
@@ -34,18 +34,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(static_cast<CharT>(__c));
+ str_.push_back(static_cast<CharT>(ch));
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/double.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/double.pass.cpp
index 197e460..1ee2c56 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/double.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/double.pass.cpp
@@ -34,18 +34,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(static_cast<CharT>(__c));
+ str_.push_back(static_cast<CharT>(ch));
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/float.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/float.pass.cpp
index d31da5a..db64b66 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/float.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/float.pass.cpp
@@ -34,18 +34,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(static_cast<CharT>(__c));
+ str_.push_back(static_cast<CharT>(ch));
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/int.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/int.pass.cpp
index 1b33280..5e601a9 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/int.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/int.pass.cpp
@@ -34,18 +34,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(static_cast<CharT>(__c));
+ str_.push_back(static_cast<CharT>(ch));
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long.pass.cpp
index 7cf4609..125c080 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long.pass.cpp
@@ -34,18 +34,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(static_cast<CharT>(__c));
+ str_.push_back(static_cast<CharT>(ch));
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_double.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_double.pass.cpp
index dba3f8a..4b235f4 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_double.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_double.pass.cpp
@@ -34,18 +34,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(static_cast<CharT>(__c));
+ str_.push_back(static_cast<CharT>(ch));
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_long.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_long.pass.cpp
index 1174a09..44b189d 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_long.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_long.pass.cpp
@@ -34,18 +34,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(static_cast<CharT>(__c));
+ str_.push_back(static_cast<CharT>(ch));
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/pointer.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/pointer.pass.cpp
index f658939..a8bdaba 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/pointer.pass.cpp
@@ -34,18 +34,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(static_cast<CharT>(__c));
+ str_.push_back(static_cast<CharT>(ch));
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/short.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/short.pass.cpp
index 3b8182c..06b6e5c 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/short.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/short.pass.cpp
@@ -34,18 +34,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(static_cast<CharT>(__c));
+ str_.push_back(static_cast<CharT>(ch));
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_int.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_int.pass.cpp
index 61057f7..e6070ef 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_int.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_int.pass.cpp
@@ -34,18 +34,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(static_cast<CharT>(__c));
+ str_.push_back(static_cast<CharT>(ch));
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long.pass.cpp
index 4558993..7f8cf46 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long.pass.cpp
@@ -34,18 +34,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(static_cast<CharT>(__c));
+ str_.push_back(static_cast<CharT>(ch));
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long_long.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long_long.pass.cpp
index 1727b36..59be66f 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long_long.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long_long.pass.cpp
@@ -34,18 +34,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(static_cast<CharT>(__c));
+ str_.push_back(static_cast<CharT>(ch));
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_short.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_short.pass.cpp
index a42cd56..6508f2d 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_short.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_short.pass.cpp
@@ -34,18 +34,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(static_cast<CharT>(__c));
+ str_.push_back(static_cast<CharT>(ch));
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT.pass.cpp
index b778da2..26bfd89 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT.pass.cpp
@@ -35,18 +35,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(__c);
+ str_.push_back(ch);
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT_pointer.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT_pointer.pass.cpp
index 29153c1..1f05684 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT_pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT_pointer.pass.cpp
@@ -35,18 +35,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(__c);
+ str_.push_back(ch);
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char.pass.cpp
index 91ee08c..0fe2c35 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char.pass.cpp
@@ -35,18 +35,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(static_cast<CharT>(__c));
+ str_.push_back(static_cast<CharT>(ch));
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_pointer.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_pointer.pass.cpp
index 1eb48d3..f5e8ad4 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_pointer.pass.cpp
@@ -35,18 +35,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(static_cast<CharT>(__c));
+ str_.push_back(static_cast<CharT>(ch));
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide.pass.cpp
index a50e376..09784c0 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide.pass.cpp
@@ -35,18 +35,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(__c);
+ str_.push_back(ch);
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide_pointer.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide_pointer.pass.cpp
index 5c900e6..2e40cf4 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide_pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide_pointer.pass.cpp
@@ -35,18 +35,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(__c);
+ str_.push_back(ch);
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char.pass.cpp
index d57d0e7..8ed0bfb 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char.pass.cpp
@@ -35,18 +35,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(static_cast<CharT>(__c));
+ str_.push_back(static_cast<CharT>(ch));
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char_pointer.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char_pointer.pass.cpp
index e51e881..e3ff047 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char_pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char_pointer.pass.cpp
@@ -35,18 +35,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(static_cast<CharT>(__c));
+ str_.push_back(static_cast<CharT>(ch));
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char.pass.cpp
index 9956f3b..32c044d 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char.pass.cpp
@@ -35,18 +35,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(static_cast<CharT>(__c));
+ str_.push_back(static_cast<CharT>(ch));
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char_pointer.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char_pointer.pass.cpp
index d87e733..199c5df 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char_pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char_pointer.pass.cpp
@@ -35,18 +35,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(static_cast<CharT>(__c));
+ str_.push_back(static_cast<CharT>(ch));
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/basic_ios.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/basic_ios.pass.cpp
index ef7e292..9d45af0 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/basic_ios.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/basic_ios.pass.cpp
@@ -35,18 +35,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(static_cast<CharT>(__c));
+ str_.push_back(static_cast<CharT>(ch));
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ios_base.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ios_base.pass.cpp
index 933e01c..21260d3 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ios_base.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ios_base.pass.cpp
@@ -34,18 +34,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(static_cast<CharT>(__c));
+ str_.push_back(static_cast<CharT>(ch));
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ostream.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ostream.pass.cpp
index 5c0604b..d4516d2 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ostream.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ostream.pass.cpp
@@ -35,18 +35,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(static_cast<CharT>(__c));
+ str_.push_back(static_cast<CharT>(ch));
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/streambuf.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/streambuf.pass.cpp
index a26450a..e510825 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/streambuf.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/streambuf.pass.cpp
@@ -41,18 +41,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(static_cast<CharT>(__c));
+ str_.push_back(static_cast<CharT>(ch));
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.manip/endl.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.manip/endl.pass.cpp
index 72df608..9e8a5c8 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.manip/endl.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.manip/endl.pass.cpp
@@ -37,18 +37,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(static_cast<CharT>(__c));
+ str_.push_back(static_cast<CharT>(ch));
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
virtual int
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.manip/ends.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.manip/ends.pass.cpp
index dcded34..f372701 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.manip/ends.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.manip/ends.pass.cpp
@@ -35,18 +35,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(static_cast<CharT>(__c));
+ str_.push_back(static_cast<CharT>(ch));
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.rvalue/CharT_pointer.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.rvalue/CharT_pointer.pass.cpp
index 83210c0..f04d468 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.rvalue/CharT_pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.rvalue/CharT_pointer.pass.cpp
@@ -39,18 +39,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(static_cast<CharT>(__c));
+ str_.push_back(static_cast<CharT>(ch));
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.unformatted/put.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.unformatted/put.pass.cpp
index 0958f83..87a94ed 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.unformatted/put.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.unformatted/put.pass.cpp
@@ -34,18 +34,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(static_cast<CharT>(__c));
+ str_.push_back(static_cast<CharT>(ch));
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.unformatted/write.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.unformatted/write.pass.cpp
index 0d6eb3f..71f9ad6 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.unformatted/write.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.unformatted/write.pass.cpp
@@ -34,18 +34,18 @@
protected:
virtual typename base::int_type
- overflow(typename base::int_type __c = base::traits_type::eof())
+ overflow(typename base::int_type ch = base::traits_type::eof())
{
- if (__c != base::traits_type::eof())
+ if (ch != base::traits_type::eof())
{
int n = static_cast<int>(str_.size());
- str_.push_back(static_cast<CharT>(__c));
+ str_.push_back(static_cast<CharT>(ch));
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1);
}
- return __c;
+ return ch;
}
};
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 6b550b5..5a8369c 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
@@ -18,7 +18,7 @@
#include "test_macros.h"
-// Test that mismatches between strings and wide streams are diagnosed
+// Test that mismatches between strings and wide streams are diagnosed
#if TEST_STD_VER > 11
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 109674d..9c0d336 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
@@ -20,7 +20,7 @@
#if TEST_STD_VER > 11
-// Test that mismatches in the traits between the quoted object and the dest string are diagnosed.
+// Test that mismatches in the traits between the quoted object and the dest string are diagnosed.
template <class charT>
struct test_traits
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/pbump2gig.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/pbump2gig.pass.cpp
new file mode 100644
index 0000000..e7bdd89
--- /dev/null
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/pbump2gig.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <streambuf>
+
+// template <class charT, class traits = char_traits<charT> >
+// class basic_streambuf;
+
+// void pbump(int n);
+//
+// REQUIRES: long_tests
+
+#include <sstream>
+#include <cassert>
+#include "test_macros.h"
+
+struct SB : std::stringbuf
+{
+ SB() : std::stringbuf(std::ios::ate|std::ios::out) { }
+ const char* pubpbase() const { return pbase(); }
+ const char* pubpptr() const { return pptr(); }
+};
+
+int main()
+{
+#ifndef TEST_HAS_NO_EXCEPTIONS
+ try {
+#endif
+ std::string str(2147483648, 'a');
+ SB sb;
+ sb.str(str);
+ assert(sb.pubpbase() <= sb.pubpptr());
+#ifndef TEST_HAS_NO_EXCEPTIONS
+ }
+ catch (const std::bad_alloc &) {}
+#endif
+}
diff --git a/test/std/input.output/string.streams/stringstream.cons/string.pass.cpp b/test/std/input.output/string.streams/stringstream.cons/string.pass.cpp
index 3776f17..b87f7eb 100644
--- a/test/std/input.output/string.streams/stringstream.cons/string.pass.cpp
+++ b/test/std/input.output/string.streams/stringstream.cons/string.pass.cpp
@@ -18,6 +18,16 @@
#include <sstream>
#include <cassert>
+template<typename T>
+struct NoDefaultAllocator : std::allocator<T>
+{
+ template<typename U> struct rebind { using other = NoDefaultAllocator<U>; };
+ NoDefaultAllocator(int id_) : id(id_) { }
+ template<typename U> NoDefaultAllocator(const NoDefaultAllocator<U>& a) : id(a.id) { }
+ int id;
+};
+
+
int main()
{
{
@@ -46,4 +56,13 @@
ss << i << ' ' << 123;
assert(ss.str() == L"456 1236 ");
}
+ { // This is https://bugs.llvm.org/show_bug.cgi?id=33727
+ typedef std::basic_string <char, std::char_traits<char>, NoDefaultAllocator<char> > S;
+ typedef std::basic_stringbuf<char, std::char_traits<char>, NoDefaultAllocator<char> > SB;
+
+ S s(NoDefaultAllocator<char>(1));
+ SB sb(s);
+ // This test is not required by the standard, but *where else* could it get the allocator?
+ assert(sb.str().get_allocator() == s.get_allocator());
+ }
}
diff --git a/test/std/iterators/iterator.primitives/iterator.operations/advance.pass.cpp b/test/std/iterators/iterator.primitives/iterator.operations/advance.pass.cpp
index e5bd560..ff1b3e7 100644
--- a/test/std/iterators/iterator.primitives/iterator.operations/advance.pass.cpp
+++ b/test/std/iterators/iterator.primitives/iterator.operations/advance.pass.cpp
@@ -35,7 +35,7 @@
#if TEST_STD_VER > 14
template <class It>
-constexpr bool
+constexpr bool
constepxr_test(It i, typename std::iterator_traits<It>::difference_type n, It x)
{
std::advance(i, n);
diff --git a/test/std/iterators/iterator.primitives/iterator.operations/next.pass.cpp b/test/std/iterators/iterator.primitives/iterator.operations/next.pass.cpp
index e257b3e..1743349 100644
--- a/test/std/iterators/iterator.primitives/iterator.operations/next.pass.cpp
+++ b/test/std/iterators/iterator.primitives/iterator.operations/next.pass.cpp
@@ -24,6 +24,9 @@
test(It i, typename std::iterator_traits<It>::difference_type n, It x)
{
assert(std::next(i, n) == x);
+
+ It (*next)(It, typename std::iterator_traits<It>::difference_type) = std::next;
+ assert(next(i, n) == x);
}
template <class It>
diff --git a/test/std/iterators/iterator.primitives/iterator.operations/prev.pass.cpp b/test/std/iterators/iterator.primitives/iterator.operations/prev.pass.cpp
index 465cda1..554445c 100644
--- a/test/std/iterators/iterator.primitives/iterator.operations/prev.pass.cpp
+++ b/test/std/iterators/iterator.primitives/iterator.operations/prev.pass.cpp
@@ -22,6 +22,9 @@
test(It i, typename std::iterator_traits<It>::difference_type n, It x)
{
assert(std::prev(i, n) == x);
+
+ It (*prev)(It, typename std::iterator_traits<It>::difference_type) = std::prev;
+ assert(prev(i, n) == x);
}
template <class It>
@@ -71,5 +74,5 @@
static_assert( constexpr_test(s+1, s), "" );
}
#endif
-
+
}
diff --git a/test/std/iterators/iterator.primitives/iterator.traits/empty.pass.cpp b/test/std/iterators/iterator.primitives/iterator.traits/empty.pass.cpp
index e48e44b..179e5e7 100644
--- a/test/std/iterators/iterator.primitives/iterator.traits/empty.pass.cpp
+++ b/test/std/iterators/iterator.primitives/iterator.traits/empty.pass.cpp
@@ -20,15 +20,15 @@
{
};
-template <class _Tp>
+template <class T>
struct has_value_type
{
private:
struct two {char lx; char lxx;};
- template <class _Up> static two test(...);
- template <class _Up> static char test(typename _Up::value_type* = 0);
+ template <class U> static two test(...);
+ template <class U> static char test(typename U::value_type* = 0);
public:
- static const bool value = sizeof(test<_Tp>(0)) == 1;
+ static const bool value = sizeof(test<T>(0)) == 1;
};
int main()
diff --git a/test/std/iterators/iterator.range/begin-end.fail.cpp b/test/std/iterators/iterator.range/begin-end.fail.cpp
index 94a3d8c..335d835 100644
--- a/test/std/iterators/iterator.range/begin-end.fail.cpp
+++ b/test/std/iterators/iterator.range/begin-end.fail.cpp
@@ -26,26 +26,26 @@
#include <cassert>
namespace Foo {
- struct FakeContainer {};
- typedef int FakeIter;
+ struct FakeContainer {};
+ typedef int FakeIter;
- FakeIter begin(const FakeContainer &) { return 1; }
- FakeIter end (const FakeContainer &) { return 2; }
- FakeIter rbegin(const FakeContainer &) { return 3; }
- FakeIter rend (const FakeContainer &) { return 4; }
+ FakeIter begin(const FakeContainer &) { return 1; }
+ FakeIter end (const FakeContainer &) { return 2; }
+ FakeIter rbegin(const FakeContainer &) { return 3; }
+ FakeIter rend (const FakeContainer &) { return 4; }
- FakeIter cbegin(const FakeContainer &) { return 11; }
- FakeIter cend (const FakeContainer &) { return 12; }
- FakeIter crbegin(const FakeContainer &) { return 13; }
- FakeIter crend (const FakeContainer &) { return 14; }
+ FakeIter cbegin(const FakeContainer &) { return 11; }
+ FakeIter cend (const FakeContainer &) { return 12; }
+ FakeIter crbegin(const FakeContainer &) { return 13; }
+ FakeIter crend (const FakeContainer &) { return 14; }
}
int main(){
// Bug #28927 - shouldn't find these via ADL
- (void) std::cbegin (Foo::FakeContainer());
- (void) std::cend (Foo::FakeContainer());
- (void) std::crbegin(Foo::FakeContainer());
- (void) std::crend (Foo::FakeContainer());
+ (void) std::cbegin (Foo::FakeContainer());
+ (void) std::cend (Foo::FakeContainer());
+ (void) std::crbegin(Foo::FakeContainer());
+ (void) std::crend (Foo::FakeContainer());
}
#endif
diff --git a/test/std/iterators/iterator.range/begin-end.pass.cpp b/test/std/iterators/iterator.range/begin-end.pass.cpp
index 2b5377f..201dd06 100644
--- a/test/std/iterators/iterator.range/begin-end.pass.cpp
+++ b/test/std/iterators/iterator.range/begin-end.pass.cpp
@@ -7,7 +7,7 @@
//
//===----------------------------------------------------------------------===//
-// XFAIL: c++03, c++98
+// XFAIL: c++98, c++03
// <iterator>
// template <class C> constexpr auto begin(C& c) -> decltype(c.begin());
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/default.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/default.pass.cpp
index ba1406a..404e02c 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/default.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/default.pass.cpp
@@ -25,6 +25,7 @@
test()
{
std::move_iterator<It> r;
+ (void)r;
}
int main()
@@ -38,6 +39,7 @@
#if TEST_STD_VER > 14
{
constexpr std::move_iterator<const char *> it;
+ (void)it;
}
#endif
}
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/default.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/default.pass.cpp
index 855dbd7..88fd0de 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/default.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/default.pass.cpp
@@ -13,7 +13,7 @@
// constexpr reverse_iterator();
//
-// constexpr in c++17
+// constexpr in C++17
#include <iterator>
@@ -25,6 +25,7 @@
test()
{
std::reverse_iterator<It> r;
+ (void)r;
}
int main()
@@ -37,6 +38,7 @@
#if TEST_STD_VER > 14
{
constexpr std::reverse_iterator<const char *> it;
+ (void)it;
}
#endif
}
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.pass.cpp
index 9bded7c..4bf816d 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.pass.cpp
@@ -13,7 +13,7 @@
// explicit constexpr reverse_iterator(Iter x);
//
-// constexpr in c++17
+// constexpr in C++17
#include <iterator>
#include <cassert>
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.pass.cpp
index 2c15743..798f9a8 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.pass.cpp
@@ -15,7 +15,7 @@
// requires HasConstructor<Iter, const U&>
// constexpr reverse_iterator(const reverse_iterator<U> &u);
//
-// constexpr in c++17
+// constexpr in C++17
#include <iterator>
#include <cassert>
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 cd15598..4cf8217 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
@@ -16,7 +16,7 @@
// constexpr reverse_iterator<Iterator>
// make_reverse_iterator(Iterator i);
//
-// constexpr in c++17
+// constexpr in C++17
#include <iterator>
#include <cassert>
diff --git "a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op\041=/test.pass.cpp" "b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op\041=/test.pass.cpp"
index f5162a7..9c53bbb 100644
--- "a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op\041=/test.pass.cpp"
+++ "b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op\041=/test.pass.cpp"
@@ -16,7 +16,7 @@
// constexpr bool
// operator!=(const reverse_iterator<Iter1>& x, const reverse_iterator<Iter2>& y);
//
-// constexpr in c++17
+// constexpr in C++17
#include <iterator>
#include <cassert>
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/post.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/post.pass.cpp
index 6a2ab27..7d9edd5 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/post.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/post.pass.cpp
@@ -13,7 +13,7 @@
// constexpr reverse_iterator operator++(int);
//
-// constexpr in c++17
+// constexpr in C++17
#include <iterator>
#include <cassert>
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/pre.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/pre.pass.cpp
index 5102422..7e75344 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/pre.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/pre.pass.cpp
@@ -13,7 +13,7 @@
// constexpr reverse_iterator& operator++();
//
-// constexpr in c++17
+// constexpr in C++17
#include <iterator>
#include <cassert>
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+/difference_type.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+/difference_type.pass.cpp
index 0c9682f..c485b04 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+/difference_type.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+/difference_type.pass.cpp
@@ -14,7 +14,7 @@
// requires RandomAccessIterator<Iter>
// constexpr reverse_iterator operator+(difference_type n) const;
//
-// constexpr in c++17
+// constexpr in C++17
#include <iterator>
#include <cassert>
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-/difference_type.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-/difference_type.pass.cpp
index 9148cc1..5c34417 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-/difference_type.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-/difference_type.pass.cpp
@@ -14,7 +14,7 @@
// requires RandomAccessIterator<Iter>
// constexpr reverse_iterator operator-(difference_type n) const;
//
-// constexpr in c++17
+// constexpr in C++17
#include <iterator>
#include <cassert>
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op.star/op_star.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op.star/op_star.pass.cpp
index 4e72756..62ca764 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op.star/op_star.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op.star/op_star.pass.cpp
@@ -13,7 +13,7 @@
// constexpr reference operator*() const;
//
-// constexpr in c++17
+// constexpr in C++17
// Be sure to respect LWG 198:
// http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#198
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.pass.cpp
index 78f6fc4..59f7218 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.pass.cpp
@@ -16,7 +16,7 @@
// constexpr reverse_iterator&
// operator=(const reverse_iterator<U>& u);
//
-// constexpr in c++17
+// constexpr in C++17
#include <iterator>
#include <cassert>
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op==/test.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op==/test.pass.cpp
index 70c9e19..1d4d091 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op==/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op==/test.pass.cpp
@@ -16,7 +16,7 @@
// constexpr bool
// operator==(const reverse_iterator<Iter1>& x, const reverse_iterator<Iter2>& y);
//
-// constexpr in c++17
+// constexpr in C++17
#include <iterator>
#include <cassert>
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opdiff/test.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opdiff/test.pass.cpp
index 73e4902..9ef8c30 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opdiff/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opdiff/test.pass.cpp
@@ -16,7 +16,7 @@
// constexpr auto operator-(const reverse_iterator<Iter1>& x, const reverse_iterator<Iter2>& y)
// -> decltype(y.base() - x.base());
//
-// constexpr in c++17
+// constexpr in C++17
#include <iterator>
#include <cstddef>
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt/test.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt/test.pass.cpp
index b6adcf4..e0e0059 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt/test.pass.cpp
@@ -16,7 +16,7 @@
// constexpr bool
// operator>(const reverse_iterator<Iter1>& x, const reverse_iterator<Iter2>& y);
//
-// constexpr in c++17
+// constexpr in C++17
#include <iterator>
#include <cassert>
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt=/test.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt=/test.pass.cpp
index dc917b2..f0ff828 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt=/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt=/test.pass.cpp
@@ -16,7 +16,7 @@
// constexpr bool
// operator>=(const reverse_iterator<Iter1>& x, const reverse_iterator<Iter2>& y);
//
-// constexpr in c++17
+// constexpr in C++17
#include <iterator>
#include <cassert>
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt/test.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt/test.pass.cpp
index 668f7d8..4ff5751 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt/test.pass.cpp
@@ -16,7 +16,7 @@
// constexpr bool
// operator<(const reverse_iterator<Iter1>& x, const reverse_iterator<Iter2>& y);
//
-// constexpr in c++17
+// constexpr in C++17
#include <iterator>
#include <cassert>
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt=/test.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt=/test.pass.cpp
index 5201bc4..9fb6310 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt=/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt=/test.pass.cpp
@@ -16,7 +16,7 @@
// constexpr bool
// operator<=(const reverse_iterator<Iter1>& x, const reverse_iterator<Iter2>& y);
//
-// constexpr in c++17
+// constexpr in C++17
#include <iterator>
#include <cassert>
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 22f2967..10bba08 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
@@ -32,6 +32,7 @@
struct test_trivial {
void operator ()() const {
constexpr std::istream_iterator<T> it;
+ (void)it;
}
};
@@ -50,6 +51,7 @@
assert(it == T());
#if TEST_STD_VER >= 11
constexpr T it2;
+ (void)it2;
#endif
}
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 74aa6f2..c71ee40 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
@@ -30,6 +30,7 @@
assert(it == T());
#if TEST_STD_VER >= 11
constexpr T it2;
+ (void)it2;
#endif
}
{
@@ -38,6 +39,7 @@
assert(it == T());
#if TEST_STD_VER >= 11
constexpr T it2;
+ (void)it2;
#endif
}
}
diff --git a/test/std/language.support/support.dynamic/align_val_t.pass.cpp b/test/std/language.support/support.dynamic/align_val_t.pass.cpp
index 0a19de9..ffb54ab 100644
--- a/test/std/language.support/support.dynamic/align_val_t.pass.cpp
+++ b/test/std/language.support/support.dynamic/align_val_t.pass.cpp
@@ -31,4 +31,4 @@
static_assert(b == std::align_val_t(32), "");
static_assert(static_cast<std::size_t>(c) == (std::size_t)-1, "");
}
-}
\ No newline at end of file
+}
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 53e26c9..ba3f930 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
@@ -10,6 +10,7 @@
// test operator new [] nothrow by replacing only operator new
// UNSUPPORTED: sanitizer-new-delete
+// XFAIL: libcpp-no-vcruntime
#include <new>
#include <cstddef>
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 b0820b1..3f81227 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
@@ -10,6 +10,7 @@
// test operator new[] replacement by replacing only operator new
// UNSUPPORTED: sanitizer-new-delete
+// XFAIL: libcpp-no-vcruntime
#include <new>
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array14.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array14.pass.cpp
index fb71580..d0b7405 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array14.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array14.pass.cpp
@@ -11,12 +11,12 @@
// UNSUPPORTED: sanitizer-new-delete, c++98, c++03, c++11
-// NOTE: Clang does not enable sized-deallocation in c++14 and beyond by
+// NOTE: Clang does not enable sized-deallocation in C++14 and beyond by
// default. It is only enabled when -fsized-deallocation is given.
// (except clang-3.6 which temporarily enabled sized-deallocation)
// UNSUPPORTED: clang, apple-clang
-// NOTE: GCC 4.9.1 does not support sized-deallocation in c++14. However
+// NOTE: GCC 4.9.1 does not support sized-deallocation in C++14. However
// GCC 5.1 does.
// XFAIL: gcc-4.7, gcc-4.8, gcc-4.9
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 dbc64ba..31e1901 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
@@ -10,6 +10,7 @@
// test operator new nothrow by replacing only operator new
// UNSUPPORTED: sanitizer-new-delete
+// XFAIL: libcpp-no-vcruntime
#include <new>
#include <cstddef>
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete14.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete14.pass.cpp
index b85b670..7a76725 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete14.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete14.pass.cpp
@@ -11,12 +11,12 @@
// UNSUPPORTED: sanitizer-new-delete, c++98, c++03, c++11
-// NOTE: Clang does not enable sized-deallocation in c++14 and beyond by
+// NOTE: Clang does not enable sized-deallocation in C++14 and beyond by
// default. It is only enabled when -fsized-deallocation is given.
// (except clang-3.6 which temporarily enabled sized-deallocation)
// UNSUPPORTED: clang, apple-clang
-// NOTE: GCC 4.9.1 does not support sized-deallocation in c++14. However
+// NOTE: GCC 4.9.1 does not support sized-deallocation in C++14. However
// GCC 5.1 does.
// XFAIL: gcc-4.7, gcc-4.8, gcc-4.9
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 88e2253..43a11ba 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
@@ -46,8 +46,8 @@
class C
{
public:
- virtual ~C() {}
- C * operator&() const { assert(false); return nullptr; } // should not be called
+ virtual ~C() {}
+ C * operator&() const { assert(false); return nullptr; } // should not be called
};
class D : private std::nested_exception {};
diff --git a/test/std/language.support/support.initlist/support.initlist.access/access.pass.cpp b/test/std/language.support/support.initlist/support.initlist.access/access.pass.cpp
index f6fd556..cadae24 100644
--- a/test/std/language.support/support.initlist/support.initlist.access/access.pass.cpp
+++ b/test/std/language.support/support.initlist/support.initlist.access/access.pass.cpp
@@ -57,5 +57,6 @@
A test1 = {3, 2, 1};
#if TEST_STD_VER > 11
constexpr B test2 = {3, 2, 1};
+ (void)test2;
#endif // TEST_STD_VER > 11
}
diff --git a/test/std/language.support/support.initlist/support.initlist.range/begin_end.pass.cpp b/test/std/language.support/support.initlist/support.initlist.range/begin_end.pass.cpp
index 102ed64..abb07dc 100644
--- a/test/std/language.support/support.initlist/support.initlist.range/begin_end.pass.cpp
+++ b/test/std/language.support/support.initlist/support.initlist.range/begin_end.pass.cpp
@@ -55,5 +55,6 @@
A test1 = {3, 2, 1};
#if TEST_STD_VER > 11
constexpr B test2 = {3, 2, 1};
+ (void)test2;
#endif // TEST_STD_VER > 11
}
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 50cfc46..6a46c37 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
@@ -37,8 +37,8 @@
round_style
*/
-template <class _Tp>
-void test(const _Tp &) {}
+template <class T>
+void test(const T &) {}
#define TEST_NUMERIC_LIMITS(type) \
test(std::numeric_limits<type>::is_specialized); \
diff --git a/test/std/language.support/support.types/byteops/and.assign.pass.cpp b/test/std/language.support/support.types/byteops/and.assign.pass.cpp
index ec1c380..4aea790 100644
--- a/test/std/language.support/support.types/byteops/and.assign.pass.cpp
+++ b/test/std/language.support/support.types/byteops/and.assign.pass.cpp
@@ -16,24 +16,24 @@
constexpr std::byte test(std::byte b1, std::byte b2) {
- std::byte bret = b1;
- return bret &= b2;
- }
+ std::byte bret = b1;
+ return bret &= b2;
+ }
int main () {
- std::byte b; // not constexpr, just used in noexcept check
- constexpr std::byte b1{static_cast<std::byte>(1)};
- constexpr std::byte b8{static_cast<std::byte>(8)};
- constexpr std::byte b9{static_cast<std::byte>(9)};
+ std::byte b; // not constexpr, just used in noexcept check
+ constexpr std::byte b1{static_cast<std::byte>(1)};
+ constexpr std::byte b8{static_cast<std::byte>(8)};
+ constexpr std::byte b9{static_cast<std::byte>(9)};
- static_assert(noexcept(b &= b), "" );
+ static_assert(noexcept(b &= b), "" );
- static_assert(std::to_integer<int>(test(b1, b8)) == 0, "");
- static_assert(std::to_integer<int>(test(b1, b9)) == 1, "");
- static_assert(std::to_integer<int>(test(b8, b9)) == 8, "");
+ static_assert(std::to_integer<int>(test(b1, b8)) == 0, "");
+ static_assert(std::to_integer<int>(test(b1, b9)) == 1, "");
+ static_assert(std::to_integer<int>(test(b8, b9)) == 8, "");
- static_assert(std::to_integer<int>(test(b8, b1)) == 0, "");
- static_assert(std::to_integer<int>(test(b9, b1)) == 1, "");
- static_assert(std::to_integer<int>(test(b9, b8)) == 8, "");
+ static_assert(std::to_integer<int>(test(b8, b1)) == 0, "");
+ static_assert(std::to_integer<int>(test(b9, b1)) == 1, "");
+ static_assert(std::to_integer<int>(test(b9, b8)) == 8, "");
}
diff --git a/test/std/language.support/support.types/byteops/and.pass.cpp b/test/std/language.support/support.types/byteops/and.pass.cpp
index 6c5419c..32c0bda 100644
--- a/test/std/language.support/support.types/byteops/and.pass.cpp
+++ b/test/std/language.support/support.types/byteops/and.pass.cpp
@@ -15,17 +15,17 @@
// constexpr byte operator&(byte l, byte r) noexcept;
int main () {
- constexpr std::byte b1{static_cast<std::byte>(1)};
- constexpr std::byte b8{static_cast<std::byte>(8)};
- constexpr std::byte b9{static_cast<std::byte>(9)};
+ constexpr std::byte b1{static_cast<std::byte>(1)};
+ constexpr std::byte b8{static_cast<std::byte>(8)};
+ constexpr std::byte b9{static_cast<std::byte>(9)};
- static_assert(noexcept(b1 & b8), "" );
+ static_assert(noexcept(b1 & b8), "" );
- static_assert(std::to_integer<int>(b1 & b8) == 0, "");
- static_assert(std::to_integer<int>(b1 & b9) == 1, "");
- static_assert(std::to_integer<int>(b8 & b9) == 8, "");
+ static_assert(std::to_integer<int>(b1 & b8) == 0, "");
+ static_assert(std::to_integer<int>(b1 & b9) == 1, "");
+ static_assert(std::to_integer<int>(b8 & b9) == 8, "");
- static_assert(std::to_integer<int>(b8 & b1) == 0, "");
- static_assert(std::to_integer<int>(b9 & b1) == 1, "");
- static_assert(std::to_integer<int>(b9 & b8) == 8, "");
+ static_assert(std::to_integer<int>(b8 & b1) == 0, "");
+ static_assert(std::to_integer<int>(b9 & b1) == 1, "");
+ static_assert(std::to_integer<int>(b9 & b8) == 8, "");
}
diff --git a/test/std/language.support/support.types/byteops/lshift.assign.fail.cpp b/test/std/language.support/support.types/byteops/lshift.assign.fail.cpp
index 8f68229..66946b4 100644
--- a/test/std/language.support/support.types/byteops/lshift.assign.fail.cpp
+++ b/test/std/language.support/support.types/byteops/lshift.assign.fail.cpp
@@ -22,10 +22,10 @@
constexpr std::byte test(std::byte b) {
- return b <<= 2.0;
- }
+ return b <<= 2.0;
+ }
int main () {
- constexpr std::byte b1 = test(std::byte{1});
+ constexpr std::byte b1 = test(std::byte{1});
}
diff --git a/test/std/language.support/support.types/byteops/lshift.assign.pass.cpp b/test/std/language.support/support.types/byteops/lshift.assign.pass.cpp
index abfeebf..6883dcc 100644
--- a/test/std/language.support/support.types/byteops/lshift.assign.pass.cpp
+++ b/test/std/language.support/support.types/byteops/lshift.assign.pass.cpp
@@ -19,18 +19,18 @@
constexpr std::byte test(std::byte b) {
- return b <<= 2;
- }
+ return b <<= 2;
+ }
int main () {
- std::byte b; // not constexpr, just used in noexcept check
- constexpr std::byte b2{static_cast<std::byte>(2)};
- constexpr std::byte b3{static_cast<std::byte>(3)};
+ std::byte b; // not constexpr, just used in noexcept check
+ constexpr std::byte b2{static_cast<std::byte>(2)};
+ constexpr std::byte b3{static_cast<std::byte>(3)};
- static_assert(noexcept(b <<= 2), "" );
+ static_assert(noexcept(b <<= 2), "" );
- static_assert(std::to_integer<int>(test(b2)) == 8, "" );
- static_assert(std::to_integer<int>(test(b3)) == 12, "" );
+ static_assert(std::to_integer<int>(test(b2)) == 8, "" );
+ static_assert(std::to_integer<int>(test(b3)) == 12, "" );
}
diff --git a/test/std/language.support/support.types/byteops/lshift.fail.cpp b/test/std/language.support/support.types/byteops/lshift.fail.cpp
index 707258c..c213935 100644
--- a/test/std/language.support/support.types/byteops/lshift.fail.cpp
+++ b/test/std/language.support/support.types/byteops/lshift.fail.cpp
@@ -18,6 +18,6 @@
// is_integral_v<IntegerType> is true.
int main () {
- constexpr std::byte b1{static_cast<std::byte>(1)};
- constexpr std::byte b2 = b1 << 2.0f;
+ constexpr std::byte b1{static_cast<std::byte>(1)};
+ constexpr std::byte b2 = b1 << 2.0f;
}
diff --git a/test/std/language.support/support.types/byteops/lshift.pass.cpp b/test/std/language.support/support.types/byteops/lshift.pass.cpp
index 15ad796..a1731b9 100644
--- a/test/std/language.support/support.types/byteops/lshift.pass.cpp
+++ b/test/std/language.support/support.types/byteops/lshift.pass.cpp
@@ -18,13 +18,13 @@
// is_integral_v<IntegerType> is true.
int main () {
- constexpr std::byte b1{static_cast<std::byte>(1)};
- constexpr std::byte b3{static_cast<std::byte>(3)};
+ constexpr std::byte b1{static_cast<std::byte>(1)};
+ constexpr std::byte b3{static_cast<std::byte>(3)};
- static_assert(noexcept(b3 << 2), "" );
+ static_assert(noexcept(b3 << 2), "" );
- static_assert(std::to_integer<int>(b1 << 1) == 2, "");
- static_assert(std::to_integer<int>(b1 << 2) == 4, "");
- static_assert(std::to_integer<int>(b3 << 4) == 48, "");
- static_assert(std::to_integer<int>(b3 << 6) == 192, "");
+ static_assert(std::to_integer<int>(b1 << 1) == 2, "");
+ static_assert(std::to_integer<int>(b1 << 2) == 4, "");
+ static_assert(std::to_integer<int>(b3 << 4) == 48, "");
+ static_assert(std::to_integer<int>(b3 << 6) == 192, "");
}
diff --git a/test/std/language.support/support.types/byteops/not.pass.cpp b/test/std/language.support/support.types/byteops/not.pass.cpp
index 53f1d91..2629001 100644
--- a/test/std/language.support/support.types/byteops/not.pass.cpp
+++ b/test/std/language.support/support.types/byteops/not.pass.cpp
@@ -15,13 +15,13 @@
// constexpr byte operator~(byte b) noexcept;
int main () {
- constexpr std::byte b1{static_cast<std::byte>(1)};
- constexpr std::byte b2{static_cast<std::byte>(2)};
- constexpr std::byte b8{static_cast<std::byte>(8)};
+ constexpr std::byte b1{static_cast<std::byte>(1)};
+ constexpr std::byte b2{static_cast<std::byte>(2)};
+ constexpr std::byte b8{static_cast<std::byte>(8)};
- static_assert(noexcept(~b1), "" );
+ static_assert(noexcept(~b1), "" );
- static_assert(std::to_integer<int>(~b1) == 254, "");
- static_assert(std::to_integer<int>(~b2) == 253, "");
- static_assert(std::to_integer<int>(~b8) == 247, "");
+ static_assert(std::to_integer<int>(~b1) == 254, "");
+ static_assert(std::to_integer<int>(~b2) == 253, "");
+ static_assert(std::to_integer<int>(~b8) == 247, "");
}
diff --git a/test/std/language.support/support.types/byteops/or.assign.pass.cpp b/test/std/language.support/support.types/byteops/or.assign.pass.cpp
index bb4a84e..0cceeaa 100644
--- a/test/std/language.support/support.types/byteops/or.assign.pass.cpp
+++ b/test/std/language.support/support.types/byteops/or.assign.pass.cpp
@@ -16,25 +16,25 @@
constexpr std::byte test(std::byte b1, std::byte b2) {
- std::byte bret = b1;
- return bret |= b2;
- }
+ std::byte bret = b1;
+ return bret |= b2;
+ }
int main () {
- std::byte b; // not constexpr, just used in noexcept check
- constexpr std::byte b1{static_cast<std::byte>(1)};
- constexpr std::byte b2{static_cast<std::byte>(2)};
- constexpr std::byte b8{static_cast<std::byte>(8)};
+ std::byte b; // not constexpr, just used in noexcept check
+ constexpr std::byte b1{static_cast<std::byte>(1)};
+ constexpr std::byte b2{static_cast<std::byte>(2)};
+ constexpr std::byte b8{static_cast<std::byte>(8)};
- static_assert(noexcept(b |= b), "" );
+ static_assert(noexcept(b |= b), "" );
- static_assert(std::to_integer<int>(test(b1, b2)) == 3, "");
- static_assert(std::to_integer<int>(test(b1, b8)) == 9, "");
- static_assert(std::to_integer<int>(test(b2, b8)) == 10, "");
+ static_assert(std::to_integer<int>(test(b1, b2)) == 3, "");
+ static_assert(std::to_integer<int>(test(b1, b8)) == 9, "");
+ static_assert(std::to_integer<int>(test(b2, b8)) == 10, "");
- static_assert(std::to_integer<int>(test(b2, b1)) == 3, "");
- static_assert(std::to_integer<int>(test(b8, b1)) == 9, "");
- static_assert(std::to_integer<int>(test(b8, b2)) == 10, "");
+ static_assert(std::to_integer<int>(test(b2, b1)) == 3, "");
+ static_assert(std::to_integer<int>(test(b8, b1)) == 9, "");
+ static_assert(std::to_integer<int>(test(b8, b2)) == 10, "");
}
diff --git a/test/std/language.support/support.types/byteops/or.pass.cpp b/test/std/language.support/support.types/byteops/or.pass.cpp
index e2b7349..62260f2 100644
--- a/test/std/language.support/support.types/byteops/or.pass.cpp
+++ b/test/std/language.support/support.types/byteops/or.pass.cpp
@@ -15,17 +15,17 @@
// constexpr byte operator|(byte l, byte r) noexcept;
int main () {
- constexpr std::byte b1{static_cast<std::byte>(1)};
- constexpr std::byte b2{static_cast<std::byte>(2)};
- constexpr std::byte b8{static_cast<std::byte>(8)};
+ constexpr std::byte b1{static_cast<std::byte>(1)};
+ constexpr std::byte b2{static_cast<std::byte>(2)};
+ constexpr std::byte b8{static_cast<std::byte>(8)};
- static_assert(noexcept(b1 | b2), "" );
+ static_assert(noexcept(b1 | b2), "" );
- static_assert(std::to_integer<int>(b1 | b2) == 3, "");
- static_assert(std::to_integer<int>(b1 | b8) == 9, "");
- static_assert(std::to_integer<int>(b2 | b8) == 10, "");
+ static_assert(std::to_integer<int>(b1 | b2) == 3, "");
+ static_assert(std::to_integer<int>(b1 | b8) == 9, "");
+ static_assert(std::to_integer<int>(b2 | b8) == 10, "");
- static_assert(std::to_integer<int>(b2 | b1) == 3, "");
- static_assert(std::to_integer<int>(b8 | b1) == 9, "");
- static_assert(std::to_integer<int>(b8 | b2) == 10, "");
+ static_assert(std::to_integer<int>(b2 | b1) == 3, "");
+ static_assert(std::to_integer<int>(b8 | b1) == 9, "");
+ static_assert(std::to_integer<int>(b8 | b2) == 10, "");
}
diff --git a/test/std/language.support/support.types/byteops/rshift.assign.fail.cpp b/test/std/language.support/support.types/byteops/rshift.assign.fail.cpp
index 44992fa..80f0bd7 100644
--- a/test/std/language.support/support.types/byteops/rshift.assign.fail.cpp
+++ b/test/std/language.support/support.types/byteops/rshift.assign.fail.cpp
@@ -22,10 +22,10 @@
constexpr std::byte test(std::byte b) {
- return b >>= 2.0;
- }
+ return b >>= 2.0;
+ }
int main () {
- constexpr std::byte b1 = test(std::byte{1});
+ constexpr std::byte b1 = test(std::byte{1});
}
diff --git a/test/std/language.support/support.types/byteops/rshift.assign.pass.cpp b/test/std/language.support/support.types/byteops/rshift.assign.pass.cpp
index 82c611c..6763995 100644
--- a/test/std/language.support/support.types/byteops/rshift.assign.pass.cpp
+++ b/test/std/language.support/support.types/byteops/rshift.assign.pass.cpp
@@ -19,17 +19,17 @@
constexpr std::byte test(std::byte b) {
- return b >>= 2;
- }
+ return b >>= 2;
+ }
int main () {
- std::byte b; // not constexpr, just used in noexcept check
- constexpr std::byte b16{static_cast<std::byte>(16)};
- constexpr std::byte b192{static_cast<std::byte>(192)};
+ std::byte b; // not constexpr, just used in noexcept check
+ constexpr std::byte b16{static_cast<std::byte>(16)};
+ constexpr std::byte b192{static_cast<std::byte>(192)};
- static_assert(noexcept(b >>= 2), "" );
+ static_assert(noexcept(b >>= 2), "" );
- static_assert(std::to_integer<int>(test(b16)) == 4, "" );
- static_assert(std::to_integer<int>(test(b192)) == 48, "" );
+ static_assert(std::to_integer<int>(test(b16)) == 4, "" );
+ static_assert(std::to_integer<int>(test(b192)) == 48, "" );
}
diff --git a/test/std/language.support/support.types/byteops/rshift.fail.cpp b/test/std/language.support/support.types/byteops/rshift.fail.cpp
index 8e142dd..b78af2e 100644
--- a/test/std/language.support/support.types/byteops/rshift.fail.cpp
+++ b/test/std/language.support/support.types/byteops/rshift.fail.cpp
@@ -18,6 +18,6 @@
// is_integral_v<IntegerType> is true.
int main () {
- constexpr std::byte b1{static_cast<std::byte>(1)};
- constexpr std::byte b2 = b1 >> 2.0f;
+ constexpr std::byte b1{static_cast<std::byte>(1)};
+ constexpr std::byte b2 = b1 >> 2.0f;
}
diff --git a/test/std/language.support/support.types/byteops/rshift.pass.cpp b/test/std/language.support/support.types/byteops/rshift.pass.cpp
index 22d3991..eec3ad6 100644
--- a/test/std/language.support/support.types/byteops/rshift.pass.cpp
+++ b/test/std/language.support/support.types/byteops/rshift.pass.cpp
@@ -19,19 +19,19 @@
constexpr std::byte test(std::byte b) {
- return b <<= 2;
- }
+ return b <<= 2;
+ }
int main () {
- constexpr std::byte b100{static_cast<std::byte>(100)};
- constexpr std::byte b115{static_cast<std::byte>(115)};
+ constexpr std::byte b100{static_cast<std::byte>(100)};
+ constexpr std::byte b115{static_cast<std::byte>(115)};
- static_assert(noexcept(b100 << 2), "" );
+ static_assert(noexcept(b100 << 2), "" );
- static_assert(std::to_integer<int>(b100 >> 1) == 50, "");
- static_assert(std::to_integer<int>(b100 >> 2) == 25, "");
- static_assert(std::to_integer<int>(b115 >> 3) == 14, "");
- static_assert(std::to_integer<int>(b115 >> 6) == 1, "");
+ static_assert(std::to_integer<int>(b100 >> 1) == 50, "");
+ static_assert(std::to_integer<int>(b100 >> 2) == 25, "");
+ static_assert(std::to_integer<int>(b115 >> 3) == 14, "");
+ static_assert(std::to_integer<int>(b115 >> 6) == 1, "");
}
diff --git a/test/std/language.support/support.types/byteops/to_integer.fail.cpp b/test/std/language.support/support.types/byteops/to_integer.fail.cpp
index fb49289..86f2ad9 100644
--- a/test/std/language.support/support.types/byteops/to_integer.fail.cpp
+++ b/test/std/language.support/support.types/byteops/to_integer.fail.cpp
@@ -18,6 +18,6 @@
// is_integral_v<IntegerType> is true.
int main () {
- constexpr std::byte b1{static_cast<std::byte>(1)};
- auto f = std::to_integer<float>(b1);
+ constexpr std::byte b1{static_cast<std::byte>(1)};
+ auto f = std::to_integer<float>(b1);
}
diff --git a/test/std/language.support/support.types/byteops/to_integer.pass.cpp b/test/std/language.support/support.types/byteops/to_integer.pass.cpp
index 4f34363..065e6d1 100644
--- a/test/std/language.support/support.types/byteops/to_integer.pass.cpp
+++ b/test/std/language.support/support.types/byteops/to_integer.pass.cpp
@@ -18,14 +18,14 @@
// is_integral_v<IntegerType> is true.
int main () {
- constexpr std::byte b1{static_cast<std::byte>(1)};
- constexpr std::byte b3{static_cast<std::byte>(3)};
+ constexpr std::byte b1{static_cast<std::byte>(1)};
+ constexpr std::byte b3{static_cast<std::byte>(3)};
- static_assert(noexcept(std::to_integer<int>(b1)), "" );
- static_assert(std::is_same<int, decltype(std::to_integer<int>(b1))>::value, "" );
- static_assert(std::is_same<long, decltype(std::to_integer<long>(b1))>::value, "" );
- static_assert(std::is_same<unsigned short, decltype(std::to_integer<unsigned short>(b1))>::value, "" );
+ static_assert(noexcept(std::to_integer<int>(b1)), "" );
+ static_assert(std::is_same<int, decltype(std::to_integer<int>(b1))>::value, "" );
+ static_assert(std::is_same<long, decltype(std::to_integer<long>(b1))>::value, "" );
+ static_assert(std::is_same<unsigned short, decltype(std::to_integer<unsigned short>(b1))>::value, "" );
- static_assert(std::to_integer<int>(b1) == 1, "");
- static_assert(std::to_integer<int>(b3) == 3, "");
+ static_assert(std::to_integer<int>(b1) == 1, "");
+ static_assert(std::to_integer<int>(b3) == 3, "");
}
diff --git a/test/std/language.support/support.types/byteops/xor.assign.pass.cpp b/test/std/language.support/support.types/byteops/xor.assign.pass.cpp
index 6a526da..07727ec 100644
--- a/test/std/language.support/support.types/byteops/xor.assign.pass.cpp
+++ b/test/std/language.support/support.types/byteops/xor.assign.pass.cpp
@@ -16,24 +16,24 @@
constexpr std::byte test(std::byte b1, std::byte b2) {
- std::byte bret = b1;
- return bret ^= b2;
- }
+ std::byte bret = b1;
+ return bret ^= b2;
+ }
int main () {
- std::byte b; // not constexpr, just used in noexcept check
- constexpr std::byte b1{static_cast<std::byte>(1)};
- constexpr std::byte b8{static_cast<std::byte>(8)};
- constexpr std::byte b9{static_cast<std::byte>(9)};
+ std::byte b; // not constexpr, just used in noexcept check
+ constexpr std::byte b1{static_cast<std::byte>(1)};
+ constexpr std::byte b8{static_cast<std::byte>(8)};
+ constexpr std::byte b9{static_cast<std::byte>(9)};
- static_assert(noexcept(b ^= b), "" );
+ static_assert(noexcept(b ^= b), "" );
- static_assert(std::to_integer<int>(test(b1, b8)) == 9, "");
- static_assert(std::to_integer<int>(test(b1, b9)) == 8, "");
- static_assert(std::to_integer<int>(test(b8, b9)) == 1, "");
+ static_assert(std::to_integer<int>(test(b1, b8)) == 9, "");
+ static_assert(std::to_integer<int>(test(b1, b9)) == 8, "");
+ static_assert(std::to_integer<int>(test(b8, b9)) == 1, "");
- static_assert(std::to_integer<int>(test(b8, b1)) == 9, "");
- static_assert(std::to_integer<int>(test(b9, b1)) == 8, "");
- static_assert(std::to_integer<int>(test(b9, b8)) == 1, "");
+ static_assert(std::to_integer<int>(test(b8, b1)) == 9, "");
+ static_assert(std::to_integer<int>(test(b9, b1)) == 8, "");
+ static_assert(std::to_integer<int>(test(b9, b8)) == 1, "");
}
diff --git a/test/std/language.support/support.types/byteops/xor.pass.cpp b/test/std/language.support/support.types/byteops/xor.pass.cpp
index e8c3b98..d7e18c9 100644
--- a/test/std/language.support/support.types/byteops/xor.pass.cpp
+++ b/test/std/language.support/support.types/byteops/xor.pass.cpp
@@ -15,17 +15,17 @@
// constexpr byte operator^(byte l, byte r) noexcept;
int main () {
- constexpr std::byte b1{static_cast<std::byte>(1)};
- constexpr std::byte b8{static_cast<std::byte>(8)};
- constexpr std::byte b9{static_cast<std::byte>(9)};
+ constexpr std::byte b1{static_cast<std::byte>(1)};
+ constexpr std::byte b8{static_cast<std::byte>(8)};
+ constexpr std::byte b9{static_cast<std::byte>(9)};
- static_assert(noexcept(b1 ^ b8), "" );
+ static_assert(noexcept(b1 ^ b8), "" );
- static_assert(std::to_integer<int>(b1 ^ b8) == 9, "");
- static_assert(std::to_integer<int>(b1 ^ b9) == 8, "");
- static_assert(std::to_integer<int>(b8 ^ b9) == 1, "");
+ static_assert(std::to_integer<int>(b1 ^ b8) == 9, "");
+ static_assert(std::to_integer<int>(b1 ^ b9) == 8, "");
+ static_assert(std::to_integer<int>(b8 ^ b9) == 1, "");
- static_assert(std::to_integer<int>(b8 ^ b1) == 9, "");
- static_assert(std::to_integer<int>(b9 ^ b1) == 8, "");
- static_assert(std::to_integer<int>(b9 ^ b8) == 1, "");
+ static_assert(std::to_integer<int>(b8 ^ b1) == 9, "");
+ static_assert(std::to_integer<int>(b9 ^ b1) == 8, "");
+ static_assert(std::to_integer<int>(b9 ^ b8) == 1, "");
}
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 2d0ed74..ffa0c90 100644
--- a/test/std/language.support/support.types/nullptr_t.pass.cpp
+++ b/test/std/language.support/support.types/nullptr_t.pass.cpp
@@ -91,7 +91,7 @@
{
#ifdef _LIBCPP_HAS_NO_NULLPTR
static_assert(!has_less<std::nullptr_t>::value, "");
- // FIXME: our c++03 nullptr emulation still allows for comparisons
+ // FIXME: our C++03 nullptr emulation still allows for comparisons
// with other pointer types by way of the conversion operator.
//static_assert(!has_less<void*>::value, "");
#else
diff --git a/test/std/localization/locale.categories/category.ctype/ctype_base.pass.cpp b/test/std/localization/locale.categories/category.ctype/ctype_base.pass.cpp
index 06c171f..c260e34 100644
--- a/test/std/localization/locale.categories/category.ctype/ctype_base.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/ctype_base.pass.cpp
@@ -36,8 +36,8 @@
#include <locale>
#include <cassert>
-template <class _Tp>
-void test(const _Tp &) {}
+template <class T>
+void test(const T &) {}
int main()
{
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/curr_symbol.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/curr_symbol.pass.cpp
index 8490b70..3a9adc4 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/curr_symbol.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/curr_symbol.pass.cpp
@@ -117,7 +117,13 @@
// GLIBC <= 2.23 uses currency_symbol="<U0440><U0443><U0431>"
// GLIBC >= 2.24 uses currency_symbol="<U20BD>"
// See also: http://www.fileformat.info/info/unicode/char/20bd/index.htm
-#if defined(TEST_GLIBC_PREREQ) && TEST_GLIBC_PREREQ(2, 24)
+#if defined(TEST_GLIBC_PREREQ)
+ #if TEST_GLIBC_PREREQ(2, 24)
+ #define TEST_GLIBC_2_24_CURRENCY_SYMBOL
+ #endif
+#endif
+
+#if defined(TEST_GLIBC_2_24_CURRENCY_SYMBOL)
assert(f.curr_symbol() == " \u20BD");
#else
assert(f.curr_symbol() == " \xD1\x80\xD1\x83\xD0\xB1");
@@ -129,7 +135,7 @@
}
{
Fwf f(LOCALE_ru_RU_UTF_8, 1);
-#if defined(TEST_GLIBC_PREREQ) && TEST_GLIBC_PREREQ(2, 24)
+#if defined(TEST_GLIBC_2_24_CURRENCY_SYMBOL)
assert(f.curr_symbol() == L" \u20BD");
#else
assert(f.curr_symbol() == L" \x440\x443\x431");
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/types.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/types.pass.cpp
index 323d856..8998bf0 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/types.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/types.pass.cpp
@@ -27,8 +27,8 @@
#include <locale>
#include <type_traits>
-template <class _Tp>
-void test(const _Tp &) {}
+template <class T>
+void test(const T &) {}
int main()
{
diff --git a/test/std/localization/locales/locale/locale.types/locale.category/category.pass.cpp b/test/std/localization/locales/locale/locale.types/locale.category/category.pass.cpp
index 8fc311a..dbab821 100644
--- a/test/std/localization/locales/locale/locale.types/locale.category/category.pass.cpp
+++ b/test/std/localization/locales/locale/locale.types/locale.category/category.pass.cpp
@@ -20,8 +20,8 @@
#include <type_traits>
#include <cassert>
-template <class _Tp>
-void test(const _Tp &) {}
+template <class T>
+void test(const T &) {}
int main()
diff --git a/test/std/numerics/c.math/ctgmath.pass.cpp b/test/std/numerics/c.math/ctgmath.pass.cpp
index 9e10690..24908ff 100644
--- a/test/std/numerics/c.math/ctgmath.pass.cpp
+++ b/test/std/numerics/c.math/ctgmath.pass.cpp
@@ -14,6 +14,7 @@
int main()
{
std::complex<double> cd;
+ (void)cd;
double x = std::sin(0);
((void)x); // Prevent unused warning
}
diff --git a/test/std/numerics/complex.number/ccmplx/ccomplex.pass.cpp b/test/std/numerics/complex.number/ccmplx/ccomplex.pass.cpp
index 4b89414..3e215c8 100644
--- a/test/std/numerics/complex.number/ccmplx/ccomplex.pass.cpp
+++ b/test/std/numerics/complex.number/ccmplx/ccomplex.pass.cpp
@@ -14,4 +14,5 @@
int main()
{
std::complex<double> d;
+ (void)d;
}
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 1b0cca0..837734f 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp
@@ -34,7 +34,6 @@
void test_edges()
{
- typedef std::complex<double> C;
const double pi = std::atan2(+0., -0.);
const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i)
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 f1aece2..deb056d 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp
@@ -34,7 +34,6 @@
void test_edges()
{
- typedef std::complex<double> C;
const double pi = std::atan2(+0., -0.);
const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i)
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 2b21309..8d74621 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp
@@ -34,7 +34,6 @@
void test_edges()
{
- typedef std::complex<double> C;
const double pi = std::atan2(+0., -0.);
const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i)
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 011f9d6..3da56c3 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp
@@ -34,7 +34,6 @@
void test_edges()
{
- typedef std::complex<double> C;
const double pi = std::atan2(+0., -0.);
const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i)
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 6dc6034..37e00c3 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp
@@ -34,7 +34,6 @@
void test_edges()
{
- typedef std::complex<double> C;
const double pi = std::atan2(+0., -0.);
const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i)
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 03ed727..be9d505 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp
@@ -34,7 +34,6 @@
void test_edges()
{
- typedef std::complex<double> C;
const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i)
{
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 a2c5539..dad5bd1 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp
@@ -34,7 +34,6 @@
void test_edges()
{
- typedef std::complex<double> C;
const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i)
{
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 7ae5998..0ab8ac2 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp
@@ -34,7 +34,6 @@
void test_edges()
{
- typedef std::complex<double> C;
const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i)
{
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 491f3fa..e310f26 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
@@ -34,7 +34,6 @@
void test_edges()
{
- typedef std::complex<double> C;
const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i)
{
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 8fa419c..1028836 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp
@@ -34,7 +34,6 @@
void test_edges()
{
- typedef std::complex<double> C;
const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i)
{
diff --git a/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan.pass.cpp b/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan.pass.cpp
index 6fdd288..34181f5 100644
--- a/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan.pass.cpp
+++ b/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan.pass.cpp
@@ -13,7 +13,7 @@
// template<class InputIterator, class OutputIterator, class T>
// OutputIterator exclusive_scan(InputIterator first, InputIterator last,
// OutputIterator result, T init);
-//
+//
#include <numeric>
#include <vector>
@@ -26,7 +26,7 @@
test(Iter1 first, Iter1 last, T init, Iter2 rFirst, Iter2 rLast)
{
std::vector<typename std::iterator_traits<Iter1>::value_type> v;
-
+
// Not in place
std::exclusive_scan(first, last, std::back_inserter(v), init);
assert(std::equal(v.begin(), v.end(), rFirst, rLast));
@@ -35,7 +35,7 @@
v.clear();
v.assign(first, last);
std::exclusive_scan(v.begin(), v.end(), v.begin(), init);
- assert(std::equal(v.begin(), v.end(), rFirst, rLast));
+ assert(std::equal(v.begin(), v.end(), rFirst, rLast));
}
diff --git a/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_init_op.pass.cpp b/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_init_op.pass.cpp
index ba1673f..c15cb16 100644
--- a/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_init_op.pass.cpp
+++ b/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_init_op.pass.cpp
@@ -13,7 +13,7 @@
// template<class InputIterator, class OutputIterator, class T, class BinaryOperation>
// OutputIterator
// exclusive_scan(InputIterator first, InputIterator last,
-// OutputIterator result,
+// OutputIterator result,
// T init, BinaryOperation binary_op); // C++17
#include <numeric>
@@ -36,7 +36,7 @@
v.clear();
v.assign(first, last);
std::exclusive_scan(v.begin(), v.end(), v.begin(), init, op);
- assert(std::equal(v.begin(), v.end(), rFirst, rLast));
+ assert(std::equal(v.begin(), v.end(), rFirst, rLast));
}
@@ -84,4 +84,3 @@
}
}
}
-
\ No newline at end of file
diff --git a/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.pass.cpp b/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.pass.cpp
new file mode 100644
index 0000000..5c42230
--- /dev/null
+++ b/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <numeric>
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// template<class InputIterator, class OutputIterator, class T>
+// OutputIterator inclusive_scan(InputIterator first, InputIterator last,
+// OutputIterator result, T init);
+//
+
+#include <numeric>
+#include <vector>
+#include <cassert>
+
+#include "test_iterators.h"
+
+template <class Iter1, class Iter2>
+void
+test(Iter1 first, Iter1 last, Iter2 rFirst, Iter2 rLast)
+{
+ std::vector<typename std::iterator_traits<Iter1>::value_type> v;
+
+// Not in place
+ std::inclusive_scan(first, last, std::back_inserter(v));
+ assert(std::equal(v.begin(), v.end(), rFirst, rLast));
+
+// In place
+ v.clear();
+ v.assign(first, last);
+ std::inclusive_scan(v.begin(), v.end(), v.begin());
+ assert(std::equal(v.begin(), v.end(), rFirst, rLast));
+}
+
+
+template <class Iter>
+void
+test()
+{
+ int ia[] = {1, 3, 5, 7, 9};
+ const int pRes[] = {1, 4, 9, 16, 25};
+ const unsigned sa = sizeof(ia) / sizeof(ia[0]);
+ static_assert(sa == sizeof(pRes) / sizeof(pRes[0])); // just to be sure
+
+ for (unsigned int i = 0; i < sa; ++i )
+ test(Iter(ia), Iter(ia + i), pRes, pRes + i);
+}
+
+int triangle(int n) { return n*(n+1)/2; }
+
+// Basic sanity
+void basic_tests()
+{
+ {
+ std::vector<int> v(10);
+ std::fill(v.begin(), v.end(), 3);
+ std::inclusive_scan(v.begin(), v.end(), v.begin());
+ for (size_t i = 0; i < v.size(); ++i)
+ assert(v[i] == (int)(i+1) * 3);
+ }
+
+ {
+ std::vector<int> v(10);
+ std::iota(v.begin(), v.end(), 0);
+ std::inclusive_scan(v.begin(), v.end(), v.begin());
+ for (size_t i = 0; i < v.size(); ++i)
+ assert(v[i] == triangle(i));
+ }
+
+ {
+ std::vector<int> v(10);
+ std::iota(v.begin(), v.end(), 1);
+ std::inclusive_scan(v.begin(), v.end(), v.begin());
+ for (size_t i = 0; i < v.size(); ++i)
+ assert(v[i] == triangle(i + 1));
+ }
+
+ {
+ std::vector<int> v, res;
+ std::inclusive_scan(v.begin(), v.end(), std::back_inserter(res));
+ assert(res.empty());
+ }
+}
+
+int main()
+{
+ basic_tests();
+
+// All the iterator categories
+ test<input_iterator <const int*> >();
+ test<forward_iterator <const int*> >();
+ test<bidirectional_iterator<const int*> >();
+ test<random_access_iterator<const int*> >();
+ test<const int*>();
+ test< int*>();
+}
diff --git a/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp b/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp
new file mode 100644
index 0000000..2c6eacc
--- /dev/null
+++ b/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp
@@ -0,0 +1,111 @@
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <numeric>
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// template<class InputIterator, class OutputIterator, class T, class BinaryOperation>
+// OutputIterator
+// inclusive_scan(InputIterator first, InputIterator last,
+// OutputIterator result,
+// BinaryOperation binary_op); // C++17
+
+#include <numeric>
+#include <vector>
+#include <cassert>
+#include <iostream>
+
+#include "test_iterators.h"
+
+template <class Iter1, class T, class Op, class Iter2>
+void
+test(Iter1 first, Iter1 last, Op op, Iter2 rFirst, Iter2 rLast)
+{
+ std::vector<typename std::iterator_traits<Iter1>::value_type> v;
+
+// Not in place
+ std::inclusive_scan(first, last, std::back_inserter(v), op);
+ assert(std::equal(v.begin(), v.end(), rFirst, rLast));
+
+// In place
+ v.clear();
+ v.assign(first, last);
+ std::inclusive_scan(v.begin(), v.end(), v.begin(), op);
+ assert(std::equal(v.begin(), v.end(), rFirst, rLast));
+}
+
+
+template <class Iter>
+void
+test()
+{
+ int ia[] = {1, 3, 5, 7, 9};
+ const int pRes[] = {1, 4, 9, 16, 25};
+ const int mRes[] = {1, 3, 15, 105, 945};
+ const unsigned sa = sizeof(ia) / sizeof(ia[0]);
+ static_assert(sa == sizeof(pRes) / sizeof(pRes[0])); // just to be sure
+ static_assert(sa == sizeof(mRes) / sizeof(mRes[0])); // just to be sure
+
+ for (unsigned int i = 0; i < sa; ++i ) {
+ test(Iter(ia), Iter(ia + i), std::plus<>(), pRes, pRes + i);
+ test(Iter(ia), Iter(ia + i), std::multiplies<>(), mRes, mRes + i);
+ }
+}
+
+int triangle(int n) { return n*(n+1)/2; }
+
+// Basic sanity
+void basic_tests()
+{
+ {
+ std::vector<int> v(10);
+ std::fill(v.begin(), v.end(), 3);
+ std::inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>());
+ for (size_t i = 0; i < v.size(); ++i)
+ assert(v[i] == (int)(i+1) * 3);
+ }
+
+ {
+ std::vector<int> v(10);
+ std::iota(v.begin(), v.end(), 0);
+ std::inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>());
+ for (size_t i = 0; i < v.size(); ++i)
+ assert(v[i] == triangle(i));
+ }
+
+ {
+ std::vector<int> v(10);
+ std::iota(v.begin(), v.end(), 1);
+ std::inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>());
+ for (size_t i = 0; i < v.size(); ++i)
+ assert(v[i] == triangle(i + 1));
+ }
+
+ {
+ std::vector<int> v, res;
+ std::inclusive_scan(v.begin(), v.end(), std::back_inserter(res), std::plus<>());
+ assert(res.empty());
+ }
+}
+
+
+int main()
+{
+
+ basic_tests();
+
+// All the iterator categories
+// test<input_iterator <const int*> >();
+// test<forward_iterator <const int*> >();
+// test<bidirectional_iterator<const int*> >();
+// test<random_access_iterator<const int*> >();
+// test<const int*>();
+// test< int*>();
+
+}
diff --git a/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.pass.cpp b/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.pass.cpp
new file mode 100644
index 0000000..6535780
--- /dev/null
+++ b/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <numeric>
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// template<class InputIterator, class OutputIterator, class T, class BinaryOperation>
+// OutputIterator
+// inclusive_scan(InputIterator first, InputIterator last,
+// OutputIterator result,
+// BinaryOperation binary_op, T init); // C++17
+
+#include <numeric>
+#include <vector>
+#include <cassert>
+
+#include "test_iterators.h"
+
+template <class Iter1, class T, class Op, class Iter2>
+void
+test(Iter1 first, Iter1 last, Op op, T init, Iter2 rFirst, Iter2 rLast)
+{
+ std::vector<typename std::iterator_traits<Iter1>::value_type> v;
+
+// Not in place
+ std::inclusive_scan(first, last, std::back_inserter(v), op, init);
+ assert(std::equal(v.begin(), v.end(), rFirst, rLast));
+
+// In place
+ v.clear();
+ v.assign(first, last);
+ std::inclusive_scan(v.begin(), v.end(), v.begin(), op, init);
+ assert(std::equal(v.begin(), v.end(), rFirst, rLast));
+}
+
+
+template <class Iter>
+void
+test()
+{
+ int ia[] = {1, 3, 5, 7, 9};
+ const int pRes[] = {1, 4, 9, 16, 25};
+ const int mRes[] = {1, 3, 15, 105, 945};
+ const unsigned sa = sizeof(ia) / sizeof(ia[0]);
+ static_assert(sa == sizeof(pRes) / sizeof(pRes[0])); // just to be sure
+ static_assert(sa == sizeof(mRes) / sizeof(mRes[0])); // just to be sure
+
+ for (unsigned int i = 0; i < sa; ++i ) {
+ test(Iter(ia), Iter(ia + i), std::plus<>(), 0, pRes, pRes + i);
+ test(Iter(ia), Iter(ia + i), std::multiplies<>(), 1, mRes, mRes + i);
+ }
+}
+
+int triangle(int n) { return n*(n+1)/2; }
+
+// Basic sanity
+void basic_tests()
+{
+ {
+ std::vector<int> v(10);
+ std::fill(v.begin(), v.end(), 3);
+ std::inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), 50);
+ for (size_t i = 0; i < v.size(); ++i)
+ assert(v[i] == 50 + (int)(i+1) * 3);
+ }
+
+ {
+ std::vector<int> v(10);
+ std::iota(v.begin(), v.end(), 0);
+ std::inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), 40);
+ for (size_t i = 0; i < v.size(); ++i)
+ assert(v[i] == 40 + triangle(i));
+ }
+
+ {
+ std::vector<int> v(10);
+ std::iota(v.begin(), v.end(), 1);
+ std::inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), 30);
+ for (size_t i = 0; i < v.size(); ++i)
+ assert(v[i] == 30 + triangle(i + 1));
+ }
+
+ {
+ std::vector<int> v, res;
+ std::inclusive_scan(v.begin(), v.end(), std::back_inserter(res), std::plus<>(), 40);
+ assert(res.empty());
+ }
+
+// Make sure that the calculations are done using the init typedef
+ {
+ std::vector<unsigned char> v(10);
+ std::iota(v.begin(), v.end(), 1);
+ std::vector<int> res;
+ std::inclusive_scan(v.begin(), v.end(), std::back_inserter(res), std::multiplies<>(), 1);
+
+ assert(res.size() == 10);
+ int j = 1;
+ assert(res[0] == 1);
+ for (size_t i = 1; i < v.size(); ++i)
+ {
+ j *= i + 1;
+ assert(res[i] == j);
+ }
+ }
+}
+
+
+int main()
+{
+
+ basic_tests();
+
+// All the iterator categories
+ test<input_iterator <const int*> >();
+ test<forward_iterator <const int*> >();
+ test<bidirectional_iterator<const int*> >();
+ test<random_access_iterator<const int*> >();
+ test<const int*>();
+ test< int*>();
+
+}
diff --git a/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.pass.cpp b/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.pass.cpp
index 6bd8a4f..1ca4543 100644
--- a/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.pass.cpp
+++ b/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.pass.cpp
@@ -137,7 +137,7 @@
// LWG#2837
{
auto res1 = std::lcm(static_cast<std::int64_t>(1234), INT32_MIN);
- (void)std::lcm(INT_MIN, 2UL); // this used to trigger UBSAN
+ (void)std::lcm(INT_MIN, 2UL); // this used to trigger UBSAN
static_assert(std::is_same_v<decltype(res1), std::int64_t>, "");
assert(res1 == 1324997410816LL);
}
diff --git a/test/std/numerics/numeric.ops/reduce/reduce_init_op.pass.cpp b/test/std/numerics/numeric.ops/reduce/reduce_init_op.pass.cpp
index 5238a1f..cff1b8c 100644
--- a/test/std/numerics/numeric.ops/reduce/reduce_init_op.pass.cpp
+++ b/test/std/numerics/numeric.ops/reduce/reduce_init_op.pass.cpp
@@ -12,7 +12,7 @@
// template<class InputIterator, class T, class BinaryOperation>
// T reduce(InputIterator first, InputIterator last, T init, BinaryOperation op);
-
+
#include <numeric>
#include <cassert>
@@ -65,10 +65,10 @@
test<random_access_iterator<const int*> >();
test<const int*>();
-// Make sure the math is done using the correct type
+// Make sure the math is done using the correct type
{
auto v = {1, 2, 3, 4, 5, 6, 7, 8};
unsigned res = std::reduce(v.begin(), v.end(), 1U, std::multiplies<>());
- assert(res == 40320); // 8! will not fit into a char
+ assert(res == 40320); // 8! will not fit into a char
}
}
diff --git a/test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp b/test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp
index 2370e9e..4964e8e 100644
--- a/test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp
+++ b/test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp
@@ -10,7 +10,7 @@
// <numeric>
// UNSUPPORTED: c++98, c++03, c++11, c++14
-// template<class InputIterator, class OutputIterator, class T,
+// template<class InputIterator, class OutputIterator, class T,
// class BinaryOperation, class UnaryOperation>
// OutputIterator transform_exclusive_scan(InputIterator first, InputIterator last,
// OutputIterator result, T init,
@@ -25,20 +25,20 @@
#include "test_iterators.h"
-template <class _Tp = void>
-struct identity : std::unary_function<_Tp, _Tp>
+template <class T = void>
+struct identity : std::unary_function<T, T>
{
- constexpr const _Tp& operator()(const _Tp& __x) const { return __x;}
+ constexpr const T& operator()(const T& x) const { return x;}
};
template <>
struct identity<void>
{
- template <class _Tp>
- constexpr auto operator()(_Tp&& __x) const
- _NOEXCEPT_(noexcept(_VSTD::forward<_Tp>(__x)))
- -> decltype (_VSTD::forward<_Tp>(__x))
- { return _VSTD::forward<_Tp>(__x); }
+ template <class T>
+ constexpr auto operator()(T&& x) const
+ _NOEXCEPT_(noexcept(_VSTD::forward<T>(x)))
+ -> decltype (_VSTD::forward<T>(x))
+ { return _VSTD::forward<T>(x); }
};
template <class Iter1, class BOp, class UOp, class T, class Iter2>
@@ -64,11 +64,11 @@
{
int ia[] = { 1, 3, 5, 7, 9};
const int pResI0[] = { 0, 1, 4, 9, 16}; // with identity
- const int mResI0[] = { 0, 0, 0, 0, 0};
+ const int mResI0[] = { 0, 0, 0, 0, 0};
const int pResN0[] = { 0, -1, -4, -9, -16}; // with negate
const int mResN0[] = { 0, 0, 0, 0, 0};
const int pResI2[] = { 2, 3, 6, 11, 18}; // with identity
- const int mResI2[] = { 2, 2, 6, 30, 210};
+ const int mResI2[] = { 2, 2, 6, 30, 210};
const int pResN2[] = { 2, 1, -2, -7, -14}; // with negate
const int mResN2[] = { 2, -2, 6, -30, 210};
const unsigned sa = sizeof(ia) / sizeof(ia[0]);
@@ -149,7 +149,7 @@
int main()
{
basic_tests();
-
+
// All the iterator categories
test<input_iterator <const int*> >();
test<forward_iterator <const int*> >();
diff --git a/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.pass.cpp b/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.pass.cpp
new file mode 100644
index 0000000..d15defc
--- /dev/null
+++ b/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <numeric>
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// template<class InputIterator, class OutputIterator, class T,
+// class BinaryOperation, class UnaryOperation>
+// OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
+// OutputIterator result,
+// BinaryOperation binary_op,
+// UnaryOperation unary_op);
+
+
+#include <numeric>
+#include <vector>
+#include <cassert>
+#include <iostream>
+
+#include "test_iterators.h"
+
+template <class T = void>
+struct identity : std::unary_function<T, T>
+{
+ constexpr const T& operator()(const T& x) const { return x;}
+};
+
+template <>
+struct identity<void>
+{
+ template <class T>
+ constexpr auto operator()(T&& x) const
+ _NOEXCEPT_(noexcept(_VSTD::forward<T>(x)))
+ -> decltype (_VSTD::forward<T>(x))
+ { return _VSTD::forward<T>(x); }
+};
+
+template <class Iter1, class BOp, class UOp, class Iter2>
+void
+test(Iter1 first, Iter1 last, BOp bop, UOp uop, Iter2 rFirst, Iter2 rLast)
+{
+ std::vector<typename std::iterator_traits<Iter1>::value_type> v;
+// Test not in-place
+ std::transform_inclusive_scan(first, last, std::back_inserter(v), bop, uop);
+ assert(std::equal(v.begin(), v.end(), rFirst, rLast));
+
+// Test in-place
+ v.clear();
+ v.assign(first, last);
+ std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), bop, uop);
+ assert(std::equal(v.begin(), v.end(), rFirst, rLast));
+}
+
+
+template <class Iter>
+void
+test()
+{
+ int ia[] = { 1, 3, 5, 7, 9};
+ const int pResI0[] = { 1, 4, 9, 16, 25}; // with identity
+ const int mResI0[] = { 1, 3, 15, 105, 945};
+ const int pResN0[] = { -1, -4, -9, -16, -25}; // with negate
+ const int mResN0[] = { -1, 3, -15, 105, -945};
+ const unsigned sa = sizeof(ia) / sizeof(ia[0]);
+ static_assert(sa == sizeof(pResI0) / sizeof(pResI0[0])); // just to be sure
+ static_assert(sa == sizeof(mResI0) / sizeof(mResI0[0])); // just to be sure
+ static_assert(sa == sizeof(pResN0) / sizeof(pResN0[0])); // just to be sure
+ static_assert(sa == sizeof(mResN0) / sizeof(mResN0[0])); // just to be sure
+
+ for (unsigned int i = 0; i < sa; ++i ) {
+ test(Iter(ia), Iter(ia + i), std::plus<>(), identity<>(), pResI0, pResI0 + i);
+ test(Iter(ia), Iter(ia + i), std::multiplies<>(), identity<>(), mResI0, mResI0 + i);
+ test(Iter(ia), Iter(ia + i), std::plus<>(), std::negate<>(), pResN0, pResN0 + i);
+ test(Iter(ia), Iter(ia + i), std::multiplies<>(), std::negate<>(), mResN0, mResN0 + i);
+ }
+}
+
+int triangle(int n) { return n*(n+1)/2; }
+
+// Basic sanity
+void basic_tests()
+{
+ {
+ std::vector<int> v(10);
+ std::fill(v.begin(), v.end(), 3);
+ std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), identity<>());
+ std::copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " "));
+ std::cout << std::endl;
+ for (size_t i = 0; i < v.size(); ++i)
+ assert(v[i] == (int)(i+1) * 3);
+ }
+
+ {
+ std::vector<int> v(10);
+ std::iota(v.begin(), v.end(), 0);
+ std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), identity<>());
+ for (size_t i = 0; i < v.size(); ++i)
+ assert(v[i] == triangle(i));
+ }
+
+ {
+ std::vector<int> v(10);
+ std::iota(v.begin(), v.end(), 1);
+ std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), identity<>());
+ for (size_t i = 0; i < v.size(); ++i)
+ assert(v[i] == triangle(i + 1));
+ }
+
+ {
+ std::vector<int> v, res;
+ std::transform_inclusive_scan(v.begin(), v.end(), std::back_inserter(res), std::plus<>(), identity<>());
+ assert(res.empty());
+ }
+}
+
+int main()
+{
+ basic_tests();
+
+// All the iterator categories
+ test<input_iterator <const int*> >();
+ test<forward_iterator <const int*> >();
+ test<bidirectional_iterator<const int*> >();
+ test<random_access_iterator<const int*> >();
+ test<const int*>();
+ test< int*>();
+}
diff --git a/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.pass.cpp b/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.pass.cpp
new file mode 100644
index 0000000..b38b9a5
--- /dev/null
+++ b/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <numeric>
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// template<class InputIterator, class OutputIterator, class T,
+// class BinaryOperation, class UnaryOperation>
+// OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
+// OutputIterator result,
+// BinaryOperation binary_op,
+// UnaryOperation unary_op,
+// T init);
+
+
+#include <numeric>
+#include <vector>
+#include <cassert>
+
+#include "test_iterators.h"
+
+template <class T = void>
+struct identity : std::unary_function<T, T>
+{
+ constexpr const T& operator()(const T& x) const { return x;}
+};
+
+template <>
+struct identity<void>
+{
+ template <class T>
+ constexpr auto operator()(T&& x) const
+ _NOEXCEPT_(noexcept(_VSTD::forward<T>(x)))
+ -> decltype (_VSTD::forward<T>(x))
+ { return _VSTD::forward<T>(x); }
+};
+
+template <class Iter1, class BOp, class UOp, class T, class Iter2>
+void
+test(Iter1 first, Iter1 last, BOp bop, UOp uop, T init, Iter2 rFirst, Iter2 rLast)
+{
+ std::vector<typename std::iterator_traits<Iter1>::value_type> v;
+// Test not in-place
+ std::transform_inclusive_scan(first, last, std::back_inserter(v), bop, uop, init);
+ assert(std::equal(v.begin(), v.end(), rFirst, rLast));
+
+// Test in-place
+ v.clear();
+ v.assign(first, last);
+ std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), bop, uop, init);
+ assert(std::equal(v.begin(), v.end(), rFirst, rLast));
+}
+
+
+template <class Iter>
+void
+test()
+{
+ int ia[] = { 1, 3, 5, 7, 9};
+ const int pResI0[] = { 1, 4, 9, 16, 25}; // with identity
+ const int mResI0[] = { 0, 0, 0, 0, 0};
+ const int pResN0[] = { -1, -4, -9, -16, -25}; // with negate
+ const int mResN0[] = { 0, 0, 0, 0, 0};
+ const int pResI2[] = { 3, 6, 11, 18, 27}; // with identity
+ const int mResI2[] = { 2, 6, 30, 210, 1890};
+ const int pResN2[] = { 1, -2, -7, -14, -23}; // with negate
+ const int mResN2[] = { -2, 6, -30, 210, -1890};
+ const unsigned sa = sizeof(ia) / sizeof(ia[0]);
+ static_assert(sa == sizeof(pResI0) / sizeof(pResI0[0])); // just to be sure
+ static_assert(sa == sizeof(mResI0) / sizeof(mResI0[0])); // just to be sure
+ static_assert(sa == sizeof(pResN0) / sizeof(pResN0[0])); // just to be sure
+ static_assert(sa == sizeof(mResN0) / sizeof(mResN0[0])); // just to be sure
+ static_assert(sa == sizeof(pResI2) / sizeof(pResI2[0])); // just to be sure
+ static_assert(sa == sizeof(mResI2) / sizeof(mResI2[0])); // just to be sure
+ static_assert(sa == sizeof(pResN2) / sizeof(pResN2[0])); // just to be sure
+ static_assert(sa == sizeof(mResN2) / sizeof(mResN2[0])); // just to be sure
+
+ for (unsigned int i = 0; i < sa; ++i ) {
+ test(Iter(ia), Iter(ia + i), std::plus<>(), identity<>(), 0, pResI0, pResI0 + i);
+ test(Iter(ia), Iter(ia + i), std::multiplies<>(), identity<>(), 0, mResI0, mResI0 + i);
+ test(Iter(ia), Iter(ia + i), std::plus<>(), std::negate<>(), 0, pResN0, pResN0 + i);
+ test(Iter(ia), Iter(ia + i), std::multiplies<>(), std::negate<>(), 0, mResN0, mResN0 + i);
+ test(Iter(ia), Iter(ia + i), std::plus<>(), identity<>(), 2, pResI2, pResI2 + i);
+ test(Iter(ia), Iter(ia + i), std::multiplies<>(), identity<>(), 2, mResI2, mResI2 + i);
+ test(Iter(ia), Iter(ia + i), std::plus<>(), std::negate<>(), 2, pResN2, pResN2 + i);
+ test(Iter(ia), Iter(ia + i), std::multiplies<>(), std::negate<>(), 2, mResN2, mResN2 + i);
+ }
+}
+
+int triangle(int n) { return n*(n+1)/2; }
+
+// Basic sanity
+void basic_tests()
+{
+ {
+ std::vector<int> v(10);
+ std::fill(v.begin(), v.end(), 3);
+ std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), identity<>(), 50);
+ for (size_t i = 0; i < v.size(); ++i)
+ assert(v[i] == 50 + (int) (i + 1) * 3);
+ }
+
+ {
+ std::vector<int> v(10);
+ std::iota(v.begin(), v.end(), 0);
+ std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), identity<>(), 30);
+ for (size_t i = 0; i < v.size(); ++i)
+ assert(v[i] == 30 + triangle(i));
+ }
+
+ {
+ std::vector<int> v(10);
+ std::iota(v.begin(), v.end(), 1);
+ std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), identity<>(), 40);
+ for (size_t i = 0; i < v.size(); ++i)
+ assert(v[i] == 40 + triangle(i + 1));
+ }
+
+ {
+ std::vector<int> v, res;
+ std::transform_inclusive_scan(v.begin(), v.end(), std::back_inserter(res), std::plus<>(), identity<>(), 1);
+ assert(res.empty());
+ }
+
+// Make sure that the calculations are done using the init typedef
+ {
+ std::vector<unsigned char> v(10);
+ std::iota(v.begin(), v.end(), 1);
+ std::vector<int> res;
+ std::transform_inclusive_scan(v.begin(), v.end(), std::back_inserter(res), std::multiplies<>(), identity<>(), 1);
+
+ assert(res.size() == 10);
+ int j = 1;
+ assert(res[0] == 1);
+ for (size_t i = 1; i < res.size(); ++i)
+ {
+ j *= i + 1;
+ assert(res[i] == j);
+ }
+ }
+}
+
+int main()
+{
+ basic_tests();
+
+// All the iterator categories
+ test<input_iterator <const int*> >();
+ test<forward_iterator <const int*> >();
+ test<bidirectional_iterator<const int*> >();
+ test<random_access_iterator<const int*> >();
+ test<const int*>();
+ test< int*>();
+}
diff --git a/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp b/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp
index c283f3e..418c57f 100644
--- a/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp
+++ b/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp
@@ -14,51 +14,51 @@
// class BinaryOperation, class UnaryOperation>
// T transform_reduce(InputIterator1 first1, InputIterator1 last1,
// T init, BinaryOperation binary_op, UnaryOperation unary_op);
-//
-
+//
+
#include <numeric>
#include <cassert>
#include "test_iterators.h"
-template <class _Tp = void>
-struct identity : std::unary_function<_Tp, _Tp>
+template <class T = void>
+struct identity : std::unary_function<T, T>
{
- constexpr const _Tp& operator()(const _Tp& __x) const { return __x;}
+ constexpr const T& operator()(const T& x) const { return x;}
};
template <>
struct identity<void>
{
- template <class _Tp>
- constexpr auto operator()(_Tp&& __x) const
- _NOEXCEPT_(noexcept(_VSTD::forward<_Tp>(__x)))
- -> decltype (_VSTD::forward<_Tp>(__x))
- { return _VSTD::forward<_Tp>(__x); }
+ template <class T>
+ constexpr auto operator()(T&& x) const
+ _NOEXCEPT_(noexcept(_VSTD::forward<T>(x)))
+ -> decltype (_VSTD::forward<T>(x))
+ { return _VSTD::forward<T>(x); }
};
-template <class _Tp = void>
+template <class T = void>
struct twice
{
- constexpr const _Tp operator()(const _Tp& __x) const noexcept { return 2 * __x; }
+ constexpr const T operator()(const T& x) const noexcept { return 2 * x; }
};
template <>
struct twice<void>
{
- template <class _Tp>
- constexpr auto operator()(const _Tp& __x) const
- _NOEXCEPT_(noexcept(2 * __x))
- -> decltype (2 * __x)
- { return 2 * __x; }
+ template <class T>
+ constexpr auto operator()(const T& x) const
+ _NOEXCEPT_(noexcept(2 * x))
+ -> decltype (2 * x)
+ { return 2 * x; }
};
template <class Iter1, class T, class BOp, class UOp>
void
test(Iter1 first1, Iter1 last1, T init, BOp bOp, UOp uOp, T x)
{
- static_assert( std::is_same_v<T,
+ static_assert( std::is_same_v<T,
decltype(std::transform_reduce(first1, last1, init, bOp, uOp))> );
assert(std::transform_reduce(first1, last1, init, bOp, uOp) == x);
}
@@ -93,7 +93,7 @@
void test_return_type()
{
T *p = nullptr;
- static_assert( std::is_same_v<Init,
+ static_assert( std::is_same_v<Init,
decltype(std::transform_reduce(p, p, Init{}, std::plus<>(), identity<>()))> );
}
@@ -115,10 +115,10 @@
test<const int*>();
test< int*>();
-// Make sure the math is done using the correct type
+// Make sure the math is done using the correct type
{
auto v = {1, 2, 3, 4, 5, 6};
unsigned res = std::transform_reduce(v.begin(), v.end(), 1U, std::multiplies<>(), twice<>());
- assert(res == 46080); // 6! * 64 will not fit into a char
+ assert(res == 46080); // 6! * 64 will not fit into a char
}
}
diff --git a/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init.pass.cpp b/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init.pass.cpp
index f36b7d4..4f8142a 100644
--- a/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init.pass.cpp
+++ b/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init.pass.cpp
@@ -24,7 +24,7 @@
void
test(Iter1 first1, Iter1 last1, Iter2 first2, T init, T x)
{
- static_assert( std::is_same_v<T,
+ static_assert( std::is_same_v<T,
decltype(std::transform_reduce(first1, last1, first2, init))> );
assert(std::transform_reduce(first1, last1, first2, init) == x);
}
@@ -52,7 +52,7 @@
void test_return_type()
{
T *p = nullptr;
- static_assert( std::is_same_v<Init,
+ static_assert( std::is_same_v<Init,
decltype(std::transform_reduce(p, p, p, Init{}))> );
}
diff --git a/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init_op_op.pass.cpp b/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init_op_op.pass.cpp
index b1b5329..41ea3b3 100644
--- a/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init_op_op.pass.cpp
+++ b/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init_op_op.pass.cpp
@@ -15,8 +15,8 @@
// T transform_reduce(InputIterator1 first1, InputIterator1 last1,
// InputIterator2 first2, T init,
// BinaryOperation1 binary_op1, BinaryOperation2 binary_op2);
-//
-
+//
+
#include <numeric>
#include <cassert>
@@ -26,7 +26,7 @@
void
test(Iter1 first1, Iter1 last1, Iter2 first2, T init, Op1 op1, Op2 op2, T x)
{
- static_assert( std::is_same_v<T,
+ static_assert( std::is_same_v<T,
decltype(std::transform_reduce(first1, last1, first2, init, op1, op2))> );
assert(std::transform_reduce(first1, last1, first2, init, op1, op2) == x);
}
@@ -54,7 +54,7 @@
void test_return_type()
{
T *p = nullptr;
- static_assert( std::is_same_v<Init,
+ static_assert( std::is_same_v<Init,
decltype(std::transform_reduce(p, p, p, Init{}, std::plus<>(), std::multiplies<>()))> );
}
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/values.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/values.pass.cpp
index 8cc523e..5666fdc 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/values.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/values.pass.cpp
@@ -28,8 +28,8 @@
#include "test_macros.h"
-template <class _Tp>
-void where(const _Tp &) {}
+template <class T>
+void where(const T &) {}
void
test1()
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/values.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/values.pass.cpp
index c592b6d..ac3f1d7 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/values.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/values.pass.cpp
@@ -27,8 +27,8 @@
#include "test_macros.h"
-template <class _Tp>
-void where(const _Tp &) {}
+template <class T>
+void where(const T &) {}
void
test1()
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 cfaddb7..82e8ffc 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
@@ -33,7 +33,6 @@
test1()
{
typedef std::lognormal_distribution<> D;
- typedef D::param_type P;
typedef std::mt19937 G;
G g;
D d(-1./8192, 0.015625);
@@ -78,7 +77,6 @@
test2()
{
typedef std::lognormal_distribution<> D;
- typedef D::param_type P;
typedef std::mt19937 G;
G g;
D d(-1./32, 0.25);
@@ -123,7 +121,6 @@
test3()
{
typedef std::lognormal_distribution<> D;
- typedef D::param_type P;
typedef std::mt19937 G;
G g;
D d(-1./8, 0.5);
@@ -168,7 +165,6 @@
test4()
{
typedef std::lognormal_distribution<> D;
- typedef D::param_type P;
typedef std::mt19937 G;
G g;
D d;
@@ -213,7 +209,6 @@
test5()
{
typedef std::lognormal_distribution<> D;
- typedef D::param_type P;
typedef std::mt19937 G;
G g;
D d(-0.78125, 1.25);
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 b207eec..6ae2301 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
@@ -33,7 +33,6 @@
{
{
typedef std::student_t_distribution<> D;
- typedef D::param_type P;
typedef std::minstd_rand G;
G g;
D d(5.5);
@@ -69,7 +68,6 @@
}
{
typedef std::student_t_distribution<> D;
- typedef D::param_type P;
typedef std::minstd_rand G;
G g;
D d(10);
@@ -105,7 +103,6 @@
}
{
typedef std::student_t_distribution<> D;
- typedef D::param_type P;
typedef std::minstd_rand G;
G g;
D d(100);
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 3999cbe..ecc663c 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
@@ -33,7 +33,6 @@
test1()
{
typedef std::extreme_value_distribution<> D;
- typedef D::param_type P;
typedef std::mt19937 G;
G g;
D d(0.5, 2);
@@ -75,7 +74,6 @@
test2()
{
typedef std::extreme_value_distribution<> D;
- typedef D::param_type P;
typedef std::mt19937 G;
G g;
D d(1, 2);
@@ -117,7 +115,6 @@
test3()
{
typedef std::extreme_value_distribution<> D;
- typedef D::param_type P;
typedef std::mt19937 G;
G g;
D d(1.5, 3);
@@ -159,7 +156,6 @@
test4()
{
typedef std::extreme_value_distribution<> D;
- typedef D::param_type P;
typedef std::mt19937 G;
G g;
D d(3, 4);
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 d0ac162..15d3a28 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
@@ -33,7 +33,6 @@
{
{
typedef std::gamma_distribution<> D;
- typedef D::param_type P;
typedef std::mt19937 G;
G g;
D d(0.5, 2);
@@ -73,7 +72,6 @@
}
{
typedef std::gamma_distribution<> D;
- typedef D::param_type P;
typedef std::mt19937 G;
G g;
D d(1, .5);
@@ -113,7 +111,6 @@
}
{
typedef std::gamma_distribution<> D;
- typedef D::param_type P;
typedef std::mt19937 G;
G g;
D d(2, 3);
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 7da4b9b..d97898e 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
@@ -44,7 +44,6 @@
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};
@@ -97,7 +96,6 @@
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};
@@ -150,7 +148,6 @@
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};
@@ -203,7 +200,6 @@
test4()
{
typedef std::piecewise_linear_distribution<> D;
- typedef D::param_type P;
typedef std::mt19937_64 G;
G g;
double b[] = {10, 14, 16};
@@ -257,7 +253,6 @@
test5()
{
typedef std::piecewise_linear_distribution<> D;
- typedef D::param_type P;
typedef std::mt19937_64 G;
G g;
double b[] = {10, 14};
@@ -312,7 +307,6 @@
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};
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.lcong/values.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.lcong/values.pass.cpp
index 2080ac5..72d5854 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.lcong/values.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.lcong/values.pass.cpp
@@ -27,8 +27,8 @@
#include "test_macros.h"
-template <class _Tp>
-void where(const _Tp &) {}
+template <class T>
+void where(const T &) {}
template <class T, T a, T c, T m>
void
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.mers/values.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.mers/values.pass.cpp
index f7834af..08d99b3 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.mers/values.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.mers/values.pass.cpp
@@ -42,8 +42,8 @@
#include "test_macros.h"
-template <class _Tp>
-void where(const _Tp &) {}
+template <class T>
+void where(const T &) {}
void
test1()
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.sub/values.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.sub/values.pass.cpp
index 6b8b4ee..02f8b22 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.sub/values.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.sub/values.pass.cpp
@@ -30,8 +30,8 @@
#include "test_macros.h"
-template <class _Tp>
-void where(const _Tp &) {}
+template <class T>
+void where(const T &) {}
void
test1()
diff --git a/test/std/re/re.alg/re.alg.match/exponential.pass.cpp b/test/std/re/re.alg/re.alg.match/exponential.pass.cpp
new file mode 100644
index 0000000..dc51bcc
--- /dev/null
+++ b/test/std/re/re.alg/re.alg.match/exponential.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <regex>
+// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: c++03
+
+// template <class BidirectionalIterator, class Allocator, class charT, class traits>
+// bool
+// regex_match(BidirectionalIterator first, BidirectionalIterator last,
+// match_results<BidirectionalIterator, Allocator>& m,
+// const basic_regex<charT, traits>& e,
+// regex_constants::match_flag_type flags = regex_constants::match_default);
+
+// Throw exception after spent too many cycles with respect to the length of the input string.
+
+#include <regex>
+#include <cassert>
+
+int main() {
+ for (std::regex_constants::syntax_option_type op :
+ {std::regex::ECMAScript, std::regex::extended, std::regex::egrep,
+ std::regex::awk}) {
+ try {
+ std::regex_match(
+ "aaaaaaaaaaaaaaaaaaaa",
+ std::regex(
+ "a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?aaaaaaaaaaaaaaaaaaaa",
+ op));
+ assert(false);
+ } catch (const std::regex_error &e) {
+ assert(e.code() == std::regex_constants::error_complexity);
+ }
+ }
+ std::string s(100000, 'a');
+ for (std::regex_constants::syntax_option_type op :
+ {std::regex::ECMAScript, std::regex::extended, std::regex::egrep,
+ std::regex::awk}) {
+ assert(std::regex_match(s, std::regex("a*", op)));
+ }
+ return 0;
+}
diff --git a/test/std/re/re.alg/re.alg.search/exponential.pass.cpp b/test/std/re/re.alg/re.alg.search/exponential.pass.cpp
new file mode 100644
index 0000000..67fc344
--- /dev/null
+++ b/test/std/re/re.alg/re.alg.search/exponential.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <regex>
+// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: c++03
+
+// template <class BidirectionalIterator, class Allocator, class charT, class traits>
+// bool
+// regex_search(BidirectionalIterator first, BidirectionalIterator last,
+// match_results<BidirectionalIterator, Allocator>& m,
+// const basic_regex<charT, traits>& e,
+// regex_constants::match_flag_type flags = regex_constants::match_default);
+
+// Throw exception after spent too many cycles with respect to the length of the input string.
+
+#include <regex>
+#include <cassert>
+
+int main() {
+ for (std::regex_constants::syntax_option_type op :
+ {std::regex::ECMAScript, std::regex::extended, std::regex::egrep,
+ std::regex::awk}) {
+ try {
+ std::regex_search(
+ "aaaaaaaaaaaaaaaaaaaa",
+ std::regex(
+ "a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?aaaaaaaaaaaaaaaaaaaa",
+ op));
+ assert(false);
+ } catch (const std::regex_error &e) {
+ assert(e.code() == std::regex_constants::error_complexity);
+ }
+ }
+ std::string s(100000, 'a');
+ for (std::regex_constants::syntax_option_type op :
+ {std::regex::ECMAScript, std::regex::extended, std::regex::egrep,
+ std::regex::awk}) {
+ assert(std::regex_search(s, std::regex("a*", op)));
+ }
+ return 0;
+}
diff --git a/test/std/re/re.alg/re.alg.search/invert_neg_word_search.pass.cpp b/test/std/re/re.alg/re.alg.search/invert_neg_word_search.pass.cpp
new file mode 100644
index 0000000..dd17d35
--- /dev/null
+++ b/test/std/re/re.alg/re.alg.search/invert_neg_word_search.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <regex>
+
+// template <class BidirectionalIterator, class Allocator, class charT, class traits>
+// bool
+// regex_search(BidirectionalIterator first, BidirectionalIterator last,
+// match_results<BidirectionalIterator, Allocator>& m,
+// const basic_regex<charT, traits>& e,
+// regex_constants::match_flag_type flags = regex_constants::match_default);
+
+#include <regex>
+#include <cassert>
+#include "test_macros.h"
+
+// PR34310
+int main()
+{
+ assert(std::regex_search("HelloWorld", std::regex("[^\\W]")));
+ assert(std::regex_search("_", std::regex("[^\\W]")));
+ return 0;
+}
diff --git a/test/std/re/re.grammar/excessive_brace_count.pass.cpp b/test/std/re/re.grammar/excessive_brace_count.pass.cpp
new file mode 100644
index 0000000..7fe5f04
--- /dev/null
+++ b/test/std/re/re.grammar/excessive_brace_count.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <regex>
+// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: c++03
+
+// the "n" in `a{n}` should be within the numeric limits.
+
+#include <regex>
+#include <cassert>
+
+int main() {
+ for (std::regex_constants::syntax_option_type op :
+ {std::regex::basic, std::regex::grep}) {
+ try {
+ (void)std::regex("a\\{100000000000000000\\}", op);
+ assert(false);
+ } catch (const std::regex_error &e) {
+ assert(e.code() == std::regex_constants::error_badbrace);
+ }
+ }
+ for (std::regex_constants::syntax_option_type op :
+ {std::regex::ECMAScript, std::regex::extended, std::regex::egrep,
+ std::regex::awk}) {
+ try {
+ (void)std::regex("a{100000000000000000}", op);
+ assert(false);
+ } catch (const std::regex_error &e) {
+ assert(e.code() == std::regex_constants::error_badbrace);
+ }
+ }
+ return 0;
+}
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 f3b57f6..f92fd88 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
@@ -95,4 +95,22 @@
assert((*i2).position() == 0);
assert((*i2).str() == "555-1234");
}
+ { // https://bugs.llvm.org/show_bug.cgi?id=33681
+ std::regex rex(".*");
+ const char foo[] = "foo";
+ // The -1 is because we don't want the implicit null from the array.
+ std::cregex_iterator i(std::begin(foo), std::end(foo) - 1, rex);
+ std::cregex_iterator e;
+ assert(i != e);
+ assert((*i).size() == 1);
+ assert((*i).str() == "foo");
+
+ ++i;
+ assert(i != e);
+ assert((*i).size() == 1);
+ assert((*i).str() == "");
+
+ ++i;
+ assert(i == e);
+ }
}
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 e699de8..42bc526 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
@@ -29,8 +29,8 @@
#include <type_traits>
#include "test_macros.h"
-template <class _Tp>
-void where(const _Tp &) {}
+template <class T>
+void where(const T &) {}
template <class CharT>
void
diff --git a/test/std/re/re.regex/re.regex.construct/bad_backref.pass.cpp b/test/std/re/re.regex/re.regex.construct/bad_backref.pass.cpp
index e66d3e9..8e886cd 100644
--- a/test/std/re/re.regex/re.regex.construct/bad_backref.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/bad_backref.pass.cpp
@@ -34,6 +34,7 @@
{
assert(error_badbackref_thrown("\\1abc")); // no references
assert(error_badbackref_thrown("ab(c)\\2def")); // only one reference
+ assert(error_badbackref_thrown("\\800000000000000000000000000000")); // overflows
// this should NOT throw, because we only should look at the '1'
// See https://bugs.llvm.org/show_bug.cgi?id=31387
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 81537ba..9e3fb07 100644
--- a/test/std/strings/basic.string/string.cons/alloc.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/alloc.pass.cpp
@@ -24,9 +24,9 @@
{
{
#if TEST_STD_VER > 14
- static_assert((noexcept(S{})), "" );
+ static_assert((noexcept(S{})), "" );
#elif TEST_STD_VER >= 11
- static_assert((noexcept(S()) == noexcept(typename S::allocator_type())), "" );
+ static_assert((noexcept(S()) == noexcept(typename S::allocator_type())), "" );
#endif
S s;
LIBCPP_ASSERT(s.__invariants());
@@ -37,9 +37,9 @@
}
{
#if TEST_STD_VER > 14
- static_assert((noexcept(S{typename S::allocator_type{}})), "" );
+ static_assert((noexcept(S{typename S::allocator_type{}})), "" );
#elif TEST_STD_VER >= 11
- static_assert((noexcept(S(typename S::allocator_type())) == std::is_nothrow_copy_constructible<typename S::allocator_type>::value), "" );
+ 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));
LIBCPP_ASSERT(s.__invariants());
@@ -58,9 +58,9 @@
{
{
#if TEST_STD_VER > 14
- static_assert((noexcept(S{})), "" );
+ static_assert((noexcept(S{})), "" );
#elif TEST_STD_VER >= 11
- static_assert((noexcept(S()) == noexcept(typename S::allocator_type())), "" );
+ static_assert((noexcept(S()) == noexcept(typename S::allocator_type())), "" );
#endif
S s;
LIBCPP_ASSERT(s.__invariants());
@@ -71,9 +71,9 @@
}
{
#if TEST_STD_VER > 14
- static_assert((noexcept(S{typename S::allocator_type{}})), "" );
+ static_assert((noexcept(S{typename S::allocator_type{}})), "" );
#elif TEST_STD_VER >= 11
- static_assert((noexcept(S(typename S::allocator_type())) == std::is_nothrow_copy_constructible<typename S::allocator_type>::value), "" );
+ 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{});
LIBCPP_ASSERT(s.__invariants());
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 982bb43..edd5c6e 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
@@ -69,9 +69,9 @@
template <class S>
void test_assign(S &s1, const S& s2)
{
- try { s1 = s2; }
- catch ( std::bad_alloc &) { return; }
- assert(false);
+ try { s1 = s2; }
+ catch ( std::bad_alloc &) { return; }
+ assert(false);
}
#endif
@@ -110,21 +110,21 @@
{
typedef poca_alloc<char> A;
typedef std::basic_string<char, std::char_traits<char>, A> S;
- const char * p1 = "This is my first string";
- const char * p2 = "This is my second string";
+ const char * p1 = "This is my first string";
+ const char * p2 = "This is my second string";
alloc_imp<char> imp1;
alloc_imp<char> imp2;
- S s1(p1, A(&imp1));
- S s2(p2, A(&imp2));
+ S s1(p1, A(&imp1));
+ S s2(p2, A(&imp2));
- assert(s1 == p1);
- assert(s2 == p2);
+ assert(s1 == p1);
+ assert(s2 == p2);
- imp2.deactivate();
- test_assign(s1, s2);
- assert(s1 == p1);
- assert(s2 == p2);
+ imp2.deactivate();
+ test_assign(s1, s2);
+ assert(s1 == p1);
+ assert(s2 == p2);
}
#endif
#endif
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 d486692..bb7bdcd 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
@@ -41,9 +41,9 @@
typedef test_allocator<char> A;
typedef std::basic_string<char, std::char_traits<char>, A> S;
#if TEST_STD_VER > 14
- static_assert((noexcept(S{})), "" );
+ static_assert((noexcept(S{})), "" );
#elif TEST_STD_VER >= 11
- static_assert((noexcept(S()) == std::is_nothrow_move_constructible<A>::value), "" );
+ static_assert((noexcept(S()) == std::is_nothrow_move_constructible<A>::value), "" );
#endif
test(S(), A(3));
test(S("1"), A(5));
@@ -55,9 +55,9 @@
typedef test_allocator<char> A;
typedef std::basic_string<char, std::char_traits<char>, A> S;
#if TEST_STD_VER > 14
- static_assert((noexcept(S{})), "" );
+ static_assert((noexcept(S{})), "" );
#elif TEST_STD_VER >= 11
- static_assert((noexcept(S()) == std::is_nothrow_move_constructible<A>::value), "" );
+ static_assert((noexcept(S()) == std::is_nothrow_move_constructible<A>::value), "" );
#endif
S s1 ( "Twas brillig, and the slivy toves did gyre and gymbal in the wabe" );
S s2 (std::move(s1), A(1));
@@ -67,9 +67,9 @@
typedef min_allocator<char> A;
typedef std::basic_string<char, std::char_traits<char>, A> S;
#if TEST_STD_VER > 14
- static_assert((noexcept(S{})), "" );
+ static_assert((noexcept(S{})), "" );
#elif TEST_STD_VER >= 11
- static_assert((noexcept(S()) == std::is_nothrow_move_constructible<A>::value), "" );
+ static_assert((noexcept(S()) == std::is_nothrow_move_constructible<A>::value), "" );
#endif
test(S(), A());
test(S("1"), A());
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 136a60f..0720543 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
@@ -16,7 +16,7 @@
// allocator_traits<allocator_type>::propagate_on_container_move_assignment::value ||
// allocator_traits<allocator_type>::is_always_equal::value); // C++17
//
-// before C++17, we use the conforming extension
+// before C++17, we use the conforming extension
// noexcept(
// allocator_type::propagate_on_container_move_assignment::value &&
// is_nothrow_move_assignable<allocator_type>::value);
@@ -81,12 +81,12 @@
}
#if TEST_STD_VER > 14
{
- // POCMA is false, always equal
+ // POCMA is false, always equal
typedef std::basic_string<char, std::char_traits<char>, some_alloc2<char>> C;
static_assert( std::is_nothrow_move_assignable<C>::value, "");
}
{
- // POCMA is false, not always equal
+ // POCMA is false, not always equal
typedef std::basic_string<char, std::char_traits<char>, some_alloc3<char>> C;
static_assert(!std::is_nothrow_move_assignable<C>::value, "");
}
diff --git a/test/std/strings/basic.string/string.cons/string_view.fail.cpp b/test/std/strings/basic.string/string.cons/string_view.fail.cpp
index 70459b2..3d3bf41 100644
--- a/test/std/strings/basic.string/string.cons/string_view.fail.cpp
+++ b/test/std/strings/basic.string/string.cons/string_view.fail.cpp
@@ -18,6 +18,6 @@
int main()
{
- std::string_view sv = "ABCDE";
- foo(sv); // requires implicit conversion from string_view to string
+ std::string_view sv = "ABCDE";
+ foo(sv); // requires implicit conversion from string_view to string
}
diff --git a/test/std/strings/basic.string/string.cons/string_view_assignment.pass.cpp b/test/std/strings/basic.string/string.cons/string_view_assignment.pass.cpp
new file mode 100644
index 0000000..1d400b7
--- /dev/null
+++ b/test/std/strings/basic.string/string.cons/string_view_assignment.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <string>
+
+// basic_string<charT,traits,Allocator>& operator=(basic_string_view<charT, traits> sv);
+
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+template <class S, class SV>
+void
+test(S s1, SV sv)
+{
+ typedef typename S::traits_type T;
+ s1 = sv;
+ LIBCPP_ASSERT(s1.__invariants());
+ assert(s1.size() == sv.size());
+ assert(T::compare(s1.data(), sv.data(), s1.size()) == 0);
+ assert(s1.capacity() >= s1.size());
+}
+
+int main()
+{
+ {
+ typedef std::string S;
+ typedef std::string_view SV;
+ test(S(), SV(""));
+ test(S("1"), SV(""));
+ test(S(), SV("1"));
+ test(S("1"), SV("2"));
+ test(S("1"), SV("2"));
+
+ test(S(),
+ SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
+ test(S("123456789"),
+ SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
+ test(S("1234567890123456789012345678901234567890123456789012345678901234567890"),
+ SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
+ test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890123456789012345678901234567890"),
+ SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
+ }
+#if TEST_STD_VER >= 11
+ {
+ typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+ typedef std::string_view SV;
+ test(S(), SV(""));
+ test(S("1"), SV(""));
+ test(S(), SV("1"));
+ test(S("1"), SV("2"));
+ test(S("1"), SV("2"));
+
+ test(S(),
+ SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
+ test(S("123456789"),
+ SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
+ test(S("1234567890123456789012345678901234567890123456789012345678901234567890"),
+ SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
+ test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890123456789012345678901234567890"),
+ SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
+ }
+#endif
+}
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 b464291..7ed5540 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
@@ -32,11 +32,11 @@
void
test_exceptions(S s, It first, It last)
{
- S aCopy = s;
+ S aCopy = s;
try {
- s.append(first, last);
- assert(false);
- }
+ s.append(first, last);
+ assert(false);
+ }
catch (...) {}
LIBCPP_ASSERT(s.__invariants());
assert(s == aCopy);
@@ -164,7 +164,7 @@
}
#endif
#ifndef TEST_HAS_NO_EXCEPTIONS
- { // test iterator operations that throw
+ { // test iterator operations that throw
typedef std::string S;
typedef ThrowingIterator<char> TIter;
typedef input_iterator<TIter> IIter;
@@ -176,33 +176,33 @@
test_exceptions(S(), TIter(s, s+10, 4, TIter::TAIncrement), TIter());
test_exceptions(S(), TIter(s, s+10, 5, TIter::TADereference), TIter());
test_exceptions(S(), TIter(s, s+10, 6, TIter::TAComparison), TIter());
- }
+ }
#endif
- { // test appending to self
+ { // test appending to self
typedef std::string S;
- S s_short = "123/";
- S s_long = "Lorem ipsum dolor sit amet, consectetur/";
+ S s_short = "123/";
+ S s_long = "Lorem ipsum dolor sit amet, consectetur/";
- s_short.append(s_short.begin(), s_short.end());
- assert(s_short == "123/123/");
- s_short.append(s_short.begin(), s_short.end());
- assert(s_short == "123/123/123/123/");
- s_short.append(s_short.begin(), s_short.end());
- assert(s_short == "123/123/123/123/123/123/123/123/");
+ s_short.append(s_short.begin(), s_short.end());
+ assert(s_short == "123/123/");
+ s_short.append(s_short.begin(), s_short.end());
+ assert(s_short == "123/123/123/123/");
+ s_short.append(s_short.begin(), s_short.end());
+ assert(s_short == "123/123/123/123/123/123/123/123/");
- s_long.append(s_long.begin(), s_long.end());
- assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
- }
+ s_long.append(s_long.begin(), s_long.end());
+ assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
+ }
- { // test appending a different type
+ { // test appending a different type
typedef std::string S;
- const uint8_t p[] = "ABCD";
+ const uint8_t p[] = "ABCD";
- S s;
- s.append(p, p + 4);
- assert(s == "ABCD");
- }
+ S s;
+ s.append(p, p + 4);
+ assert(s == "ABCD");
+ }
{ // test with a move iterator that returns char&&
typedef forward_iterator<const char*> It;
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 eb552ca..823905d 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
@@ -62,19 +62,19 @@
}
#endif
- { // test appending to self
+ { // test appending to self
typedef std::string S;
- S s_short = "123/";
- S s_long = "Lorem ipsum dolor sit amet, consectetur/";
+ S s_short = "123/";
+ S s_long = "Lorem ipsum dolor sit amet, consectetur/";
- s_short.append(s_short.c_str());
- assert(s_short == "123/123/");
- s_short.append(s_short.c_str());
- assert(s_short == "123/123/123/123/");
- s_short.append(s_short.c_str());
- assert(s_short == "123/123/123/123/123/123/123/123/");
+ s_short.append(s_short.c_str());
+ assert(s_short == "123/123/");
+ s_short.append(s_short.c_str());
+ assert(s_short == "123/123/123/123/");
+ s_short.append(s_short.c_str());
+ assert(s_short == "123/123/123/123/123/123/123/123/");
- s_long.append(s_long.c_str());
- assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
- }
+ s_long.append(s_long.c_str());
+ assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
+ }
}
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 fc80d7c..f09ec68 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
@@ -71,19 +71,19 @@
}
#endif
- { // test appending to self
+ { // test appending to self
typedef std::string S;
- S s_short = "123/";
- S s_long = "Lorem ipsum dolor sit amet, consectetur/";
+ S s_short = "123/";
+ S s_long = "Lorem ipsum dolor sit amet, consectetur/";
- s_short.append(s_short.data(), s_short.size());
- assert(s_short == "123/123/");
- s_short.append(s_short.data(), s_short.size());
- assert(s_short == "123/123/123/123/");
- s_short.append(s_short.data(), s_short.size());
- assert(s_short == "123/123/123/123/123/123/123/123/");
+ s_short.append(s_short.data(), s_short.size());
+ assert(s_short == "123/123/");
+ s_short.append(s_short.data(), s_short.size());
+ assert(s_short == "123/123/123/123/");
+ s_short.append(s_short.data(), s_short.size());
+ assert(s_short == "123/123/123/123/123/123/123/123/");
- s_long.append(s_long.data(), s_long.size());
- assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
- }
+ s_long.append(s_long.data(), s_long.size());
+ assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
+ }
}
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 e5312e6..cb83f25 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
@@ -33,10 +33,10 @@
void
test_exceptions(S s, It first, It last)
{
- S aCopy = s;
+ S aCopy = s;
try {
- s.assign(first, last);
- assert(false);
+ s.assign(first, last);
+ assert(false);
}
catch (...) {}
LIBCPP_ASSERT(s.__invariants());
@@ -165,7 +165,7 @@
}
#endif
#ifndef TEST_HAS_NO_EXCEPTIONS
- { // test iterator operations that throw
+ { // test iterator operations that throw
typedef std::string S;
typedef ThrowingIterator<char> TIter;
typedef input_iterator<TIter> IIter;
@@ -177,32 +177,32 @@
test_exceptions(S(), TIter(s, s+10, 4, TIter::TAIncrement), TIter());
test_exceptions(S(), TIter(s, s+10, 5, TIter::TADereference), TIter());
test_exceptions(S(), TIter(s, s+10, 6, TIter::TAComparison), TIter());
- }
+ }
#endif
- { // test assigning to self
+ { // test assigning to self
typedef std::string S;
- S s_short = "123/";
- S s_long = "Lorem ipsum dolor sit amet, consectetur/";
+ S s_short = "123/";
+ S s_long = "Lorem ipsum dolor sit amet, consectetur/";
- s_short.assign(s_short.begin(), s_short.end());
- assert(s_short == "123/");
- s_short.assign(s_short.begin() + 2, s_short.end());
- assert(s_short == "3/");
+ s_short.assign(s_short.begin(), s_short.end());
+ assert(s_short == "123/");
+ s_short.assign(s_short.begin() + 2, s_short.end());
+ assert(s_short == "3/");
- s_long.assign(s_long.begin(), s_long.end());
- assert(s_long == "Lorem ipsum dolor sit amet, consectetur/");
+ s_long.assign(s_long.begin(), s_long.end());
+ assert(s_long == "Lorem ipsum dolor sit amet, consectetur/");
- s_long.assign(s_long.begin() + 30, s_long.end());
- assert(s_long == "nsectetur/");
- }
+ s_long.assign(s_long.begin() + 30, s_long.end());
+ assert(s_long == "nsectetur/");
+ }
- { // test assigning a different type
+ { // test assigning a different type
typedef std::string S;
- const uint8_t p[] = "ABCD";
+ const uint8_t p[] = "ABCD";
- S s;
- s.assign(p, p + 4);
- assert(s == "ABCD");
- }
+ S s;
+ s.assign(p, p + 4);
+ assert(s == "ABCD");
+ }
}
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 b0876b3..b592455 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
@@ -62,17 +62,17 @@
}
#endif
- { // test assignment to self
+ { // test assignment to self
typedef std::string S;
- S s_short = "123/";
- S s_long = "Lorem ipsum dolor sit amet, consectetur/";
+ S s_short = "123/";
+ S s_long = "Lorem ipsum dolor sit amet, consectetur/";
- s_short.assign(s_short.c_str());
- assert(s_short == "123/");
- s_short.assign(s_short.c_str() + 2);
- assert(s_short == "3/");
+ s_short.assign(s_short.c_str());
+ assert(s_short == "123/");
+ s_short.assign(s_short.c_str() + 2);
+ assert(s_short == "3/");
- s_long.assign(s_long.c_str() + 30);
- assert(s_long == "nsectetur/");
- }
+ s_long.assign(s_long.c_str() + 30);
+ assert(s_long == "nsectetur/");
+ }
}
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 97a9990..70b0061 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
@@ -70,20 +70,20 @@
S("12345678901234567890"));
}
#endif
- { // test assign to self
+ { // test assign to self
typedef std::string S;
- S s_short = "123/";
- S s_long = "Lorem ipsum dolor sit amet, consectetur/";
+ S s_short = "123/";
+ S s_long = "Lorem ipsum dolor sit amet, consectetur/";
- s_short.assign(s_short.data(), s_short.size());
- assert(s_short == "123/");
- s_short.assign(s_short.data() + 2, s_short.size() - 2);
- assert(s_short == "3/");
+ s_short.assign(s_short.data(), s_short.size());
+ assert(s_short == "123/");
+ s_short.assign(s_short.data() + 2, s_short.size() - 2);
+ assert(s_short == "3/");
- s_long.assign(s_long.data(), s_long.size());
- assert(s_long == "Lorem ipsum dolor sit amet, consectetur/");
+ s_long.assign(s_long.data(), s_long.size());
+ assert(s_long == "Lorem ipsum dolor sit amet, consectetur/");
- s_long.assign(s_long.data() + 2, 8 );
- assert(s_long == "rem ipsu");
- }
+ s_long.assign(s_long.data() + 2, 8 );
+ assert(s_long == "rem ipsu");
+ }
}
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 2c8b6e4..cb4b40f 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
@@ -39,7 +39,7 @@
test_exceptions(S s, typename S::difference_type pos, It first, It last)
{
typename S::const_iterator p = s.cbegin() + pos;
- S aCopy = s;
+ S aCopy = s;
try {
s.insert(p, first, last);
assert(false);
@@ -145,7 +145,7 @@
}
#endif
#ifndef TEST_HAS_NO_EXCEPTIONS
- { // test iterator operations that throw
+ { // test iterator operations that throw
typedef std::string S;
typedef ThrowingIterator<char> TIter;
typedef input_iterator<TIter> IIter;
@@ -157,7 +157,7 @@
test_exceptions(S(), 0, TIter(s, s+10, 4, TIter::TAIncrement), TIter());
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
{
@@ -170,30 +170,30 @@
}
#endif
- { // test inserting into self
+ { // test inserting into self
typedef std::string S;
- S s_short = "123/";
- S s_long = "Lorem ipsum dolor sit amet, consectetur/";
+ S s_short = "123/";
+ S s_long = "Lorem ipsum dolor sit amet, consectetur/";
- s_short.insert(s_short.begin(), s_short.begin(), s_short.end());
- assert(s_short == "123/123/");
- s_short.insert(s_short.begin(), s_short.begin(), s_short.end());
- assert(s_short == "123/123/123/123/");
- s_short.insert(s_short.begin(), s_short.begin(), s_short.end());
- assert(s_short == "123/123/123/123/123/123/123/123/");
+ s_short.insert(s_short.begin(), s_short.begin(), s_short.end());
+ assert(s_short == "123/123/");
+ s_short.insert(s_short.begin(), s_short.begin(), s_short.end());
+ assert(s_short == "123/123/123/123/");
+ s_short.insert(s_short.begin(), s_short.begin(), s_short.end());
+ assert(s_short == "123/123/123/123/123/123/123/123/");
- s_long.insert(s_long.begin(), s_long.begin(), s_long.end());
- assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
- }
+ s_long.insert(s_long.begin(), s_long.begin(), s_long.end());
+ assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
+ }
- { // test assigning a different type
+ { // test assigning a different type
typedef std::string S;
const uint8_t p[] = "ABCD";
S s;
s.insert(s.begin(), p, p + 4);
assert(s == "ABCD");
- }
+ }
{ // test with a move iterator that returns char&&
typedef input_iterator<const char*> It;
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 e49f57a..b4505a4 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
@@ -219,19 +219,19 @@
}
#endif
- { // test inserting into self
+ { // test inserting into self
typedef std::string S;
- S s_short = "123/";
- S s_long = "Lorem ipsum dolor sit amet, consectetur/";
+ S s_short = "123/";
+ S s_long = "Lorem ipsum dolor sit amet, consectetur/";
- s_short.insert(0, s_short.c_str());
- assert(s_short == "123/123/");
- s_short.insert(0, s_short.c_str());
- assert(s_short == "123/123/123/123/");
- s_short.insert(0, s_short.c_str());
- assert(s_short == "123/123/123/123/123/123/123/123/");
+ s_short.insert(0, s_short.c_str());
+ assert(s_short == "123/123/");
+ s_short.insert(0, s_short.c_str());
+ assert(s_short == "123/123/123/123/");
+ s_short.insert(0, s_short.c_str());
+ assert(s_short == "123/123/123/123/123/123/123/123/");
- s_long.insert(0, s_long.c_str());
- assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
- }
+ s_long.insert(0, s_long.c_str());
+ assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
+ }
}
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 a42a60d..ee5991c 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
@@ -700,19 +700,19 @@
}
#endif
- { // test inserting into self
+ { // test inserting into self
typedef std::string S;
- S s_short = "123/";
- S s_long = "Lorem ipsum dolor sit amet, consectetur/";
+ S s_short = "123/";
+ S s_long = "Lorem ipsum dolor sit amet, consectetur/";
- s_short.insert(0, s_short.data(), s_short.size());
- assert(s_short == "123/123/");
- s_short.insert(0, s_short.data(), s_short.size());
- assert(s_short == "123/123/123/123/");
- s_short.insert(0, s_short.data(), s_short.size());
- assert(s_short == "123/123/123/123/123/123/123/123/");
+ s_short.insert(0, s_short.data(), s_short.size());
+ assert(s_short == "123/123/");
+ s_short.insert(0, s_short.data(), s_short.size());
+ assert(s_short == "123/123/123/123/");
+ s_short.insert(0, s_short.data(), s_short.size());
+ assert(s_short == "123/123/123/123/123/123/123/123/");
- s_long.insert(0, s_long.data(), s_long.size());
- assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
- }
+ s_long.insert(0, s_long.data(), s_long.size());
+ assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
+ }
}
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/string_view.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/string_view.pass.cpp
new file mode 100644
index 0000000..970cbcb
--- /dev/null
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/string_view.pass.cpp
@@ -0,0 +1,239 @@
+//===----------------------------------------------------------------------===//
+//
+// The 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>
+
+// basic_string<charT,traits,Allocator>&
+// insert(size_type pos, string_view sv);
+
+#include <string>
+#include <stdexcept>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+template <class S, class SV>
+void
+test(S s, typename S::size_type pos, SV sv, S expected)
+{
+ const typename S::size_type old_size = s.size();
+ S s0 = s;
+ if (pos <= old_size)
+ {
+ s.insert(pos, sv);
+ LIBCPP_ASSERT(s.__invariants());
+ assert(s == expected);
+ }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+ else
+ {
+ try
+ {
+ s.insert(pos, sv);
+ assert(false);
+ }
+ catch (std::out_of_range&)
+ {
+ assert(pos > old_size);
+ assert(s == s0);
+ }
+ }
+#endif
+}
+
+int main()
+{
+ {
+ typedef std::string S;
+ typedef std::string_view SV;
+ test(S(""), 0, SV(""), S(""));
+ test(S(""), 0, SV("12345"), S("12345"));
+ test(S(""), 0, SV("1234567890"), S("1234567890"));
+ test(S(""), 0, SV("12345678901234567890"), S("12345678901234567890"));
+ test(S(""), 1, SV(""), S("can't happen"));
+ test(S(""), 1, SV("12345"), S("can't happen"));
+ test(S(""), 1, SV("1234567890"), S("can't happen"));
+ test(S(""), 1, SV("12345678901234567890"), S("can't happen"));
+ test(S("abcde"), 0, SV(""), S("abcde"));
+ test(S("abcde"), 0, SV("12345"), S("12345abcde"));
+ test(S("abcde"), 0, SV("1234567890"), S("1234567890abcde"));
+ test(S("abcde"), 0, SV("12345678901234567890"), S("12345678901234567890abcde"));
+ test(S("abcde"), 1, SV(""), S("abcde"));
+ test(S("abcde"), 1, SV("12345"), S("a12345bcde"));
+ test(S("abcde"), 1, SV("1234567890"), S("a1234567890bcde"));
+ test(S("abcde"), 1, SV("12345678901234567890"), S("a12345678901234567890bcde"));
+ test(S("abcde"), 2, SV(""), S("abcde"));
+ test(S("abcde"), 2, SV("12345"), S("ab12345cde"));
+ test(S("abcde"), 2, SV("1234567890"), S("ab1234567890cde"));
+ test(S("abcde"), 2, SV("12345678901234567890"), S("ab12345678901234567890cde"));
+ test(S("abcde"), 4, SV(""), S("abcde"));
+ test(S("abcde"), 4, SV("12345"), S("abcd12345e"));
+ test(S("abcde"), 4, SV("1234567890"), S("abcd1234567890e"));
+ test(S("abcde"), 4, SV("12345678901234567890"), S("abcd12345678901234567890e"));
+ test(S("abcde"), 5, SV(""), S("abcde"));
+ test(S("abcde"), 5, SV("12345"), S("abcde12345"));
+ test(S("abcde"), 5, SV("1234567890"), S("abcde1234567890"));
+ test(S("abcde"), 5, SV("12345678901234567890"), S("abcde12345678901234567890"));
+ test(S("abcde"), 6, SV(""), S("can't happen"));
+ test(S("abcde"), 6, SV("12345"), S("can't happen"));
+ test(S("abcde"), 6, SV("1234567890"), S("can't happen"));
+ test(S("abcde"), 6, SV("12345678901234567890"), S("can't happen"));
+ test(S("abcdefghij"), 0, SV(""), S("abcdefghij"));
+ test(S("abcdefghij"), 0, SV("12345"), S("12345abcdefghij"));
+ test(S("abcdefghij"), 0, SV("1234567890"), S("1234567890abcdefghij"));
+ test(S("abcdefghij"), 0, SV("12345678901234567890"), S("12345678901234567890abcdefghij"));
+ test(S("abcdefghij"), 1, SV(""), S("abcdefghij"));
+ test(S("abcdefghij"), 1, SV("12345"), S("a12345bcdefghij"));
+ test(S("abcdefghij"), 1, SV("1234567890"), S("a1234567890bcdefghij"));
+ test(S("abcdefghij"), 1, SV("12345678901234567890"), S("a12345678901234567890bcdefghij"));
+ test(S("abcdefghij"), 5, SV(""), S("abcdefghij"));
+ test(S("abcdefghij"), 5, SV("12345"), S("abcde12345fghij"));
+ test(S("abcdefghij"), 5, SV("1234567890"), S("abcde1234567890fghij"));
+ test(S("abcdefghij"), 5, SV("12345678901234567890"), S("abcde12345678901234567890fghij"));
+ test(S("abcdefghij"), 9, SV(""), S("abcdefghij"));
+ test(S("abcdefghij"), 9, SV("12345"), S("abcdefghi12345j"));
+ test(S("abcdefghij"), 9, SV("1234567890"), S("abcdefghi1234567890j"));
+ test(S("abcdefghij"), 9, SV("12345678901234567890"), S("abcdefghi12345678901234567890j"));
+ test(S("abcdefghij"), 10, SV(""), S("abcdefghij"));
+ test(S("abcdefghij"), 10, SV("12345"), S("abcdefghij12345"));
+ test(S("abcdefghij"), 10, SV("1234567890"), S("abcdefghij1234567890"));
+ test(S("abcdefghij"), 10, SV("12345678901234567890"), S("abcdefghij12345678901234567890"));
+ test(S("abcdefghij"), 11, SV(""), S("can't happen"));
+ test(S("abcdefghij"), 11, SV("12345"), S("can't happen"));
+ test(S("abcdefghij"), 11, SV("1234567890"), S("can't happen"));
+ test(S("abcdefghij"), 11, SV("12345678901234567890"), S("can't happen"));
+ test(S("abcdefghijklmnopqrst"), 0, SV(""), S("abcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 0, SV("12345"), S("12345abcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 0, SV("1234567890"), S("1234567890abcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 0, SV("12345678901234567890"), S("12345678901234567890abcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 1, SV(""), S("abcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 1, SV("12345"), S("a12345bcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 1, SV("1234567890"), S("a1234567890bcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 1, SV("12345678901234567890"), S("a12345678901234567890bcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 10, SV(""), S("abcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 10, SV("12345"), S("abcdefghij12345klmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 10, SV("1234567890"), S("abcdefghij1234567890klmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 10, SV("12345678901234567890"), S("abcdefghij12345678901234567890klmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 19, SV(""), S("abcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 19, SV("12345"), S("abcdefghijklmnopqrs12345t"));
+ test(S("abcdefghijklmnopqrst"), 19, SV("1234567890"), S("abcdefghijklmnopqrs1234567890t"));
+ test(S("abcdefghijklmnopqrst"), 19, SV("12345678901234567890"), S("abcdefghijklmnopqrs12345678901234567890t"));
+ test(S("abcdefghijklmnopqrst"), 20, SV(""), S("abcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 20, SV("12345"), S("abcdefghijklmnopqrst12345"));
+ test(S("abcdefghijklmnopqrst"), 20, SV("1234567890"), S("abcdefghijklmnopqrst1234567890"));
+ test(S("abcdefghijklmnopqrst"), 20, SV("12345678901234567890"), S("abcdefghijklmnopqrst12345678901234567890"));
+ test(S("abcdefghijklmnopqrst"), 21, SV(""), S("can't happen"));
+ test(S("abcdefghijklmnopqrst"), 21, SV("12345"), S("can't happen"));
+ test(S("abcdefghijklmnopqrst"), 21, SV("1234567890"), S("can't happen"));
+ test(S("abcdefghijklmnopqrst"), 21, SV("12345678901234567890"), S("can't happen"));
+ }
+#if TEST_STD_VER >= 11
+ {
+ typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+ typedef std::string_view SV;
+ test(S(""), 0, SV(""), S(""));
+ test(S(""), 0, SV("12345"), S("12345"));
+ test(S(""), 0, SV("1234567890"), S("1234567890"));
+ test(S(""), 0, SV("12345678901234567890"), S("12345678901234567890"));
+ test(S(""), 1, SV(""), S("can't happen"));
+ test(S(""), 1, SV("12345"), S("can't happen"));
+ test(S(""), 1, SV("1234567890"), S("can't happen"));
+ test(S(""), 1, SV("12345678901234567890"), S("can't happen"));
+ test(S("abcde"), 0, SV(""), S("abcde"));
+ test(S("abcde"), 0, SV("12345"), S("12345abcde"));
+ test(S("abcde"), 0, SV("1234567890"), S("1234567890abcde"));
+ test(S("abcde"), 0, SV("12345678901234567890"), S("12345678901234567890abcde"));
+ test(S("abcde"), 1, SV(""), S("abcde"));
+ test(S("abcde"), 1, SV("12345"), S("a12345bcde"));
+ test(S("abcde"), 1, SV("1234567890"), S("a1234567890bcde"));
+ test(S("abcde"), 1, SV("12345678901234567890"), S("a12345678901234567890bcde"));
+ test(S("abcde"), 2, SV(""), S("abcde"));
+ test(S("abcde"), 2, SV("12345"), S("ab12345cde"));
+ test(S("abcde"), 2, SV("1234567890"), S("ab1234567890cde"));
+ test(S("abcde"), 2, SV("12345678901234567890"), S("ab12345678901234567890cde"));
+ test(S("abcde"), 4, SV(""), S("abcde"));
+ test(S("abcde"), 4, SV("12345"), S("abcd12345e"));
+ test(S("abcde"), 4, SV("1234567890"), S("abcd1234567890e"));
+ test(S("abcde"), 4, SV("12345678901234567890"), S("abcd12345678901234567890e"));
+ test(S("abcde"), 5, SV(""), S("abcde"));
+ test(S("abcde"), 5, SV("12345"), S("abcde12345"));
+ test(S("abcde"), 5, SV("1234567890"), S("abcde1234567890"));
+ test(S("abcde"), 5, SV("12345678901234567890"), S("abcde12345678901234567890"));
+ test(S("abcde"), 6, SV(""), S("can't happen"));
+ test(S("abcde"), 6, SV("12345"), S("can't happen"));
+ test(S("abcde"), 6, SV("1234567890"), S("can't happen"));
+ test(S("abcde"), 6, SV("12345678901234567890"), S("can't happen"));
+ test(S("abcdefghij"), 0, SV(""), S("abcdefghij"));
+ test(S("abcdefghij"), 0, SV("12345"), S("12345abcdefghij"));
+ test(S("abcdefghij"), 0, SV("1234567890"), S("1234567890abcdefghij"));
+ test(S("abcdefghij"), 0, SV("12345678901234567890"), S("12345678901234567890abcdefghij"));
+ test(S("abcdefghij"), 1, SV(""), S("abcdefghij"));
+ test(S("abcdefghij"), 1, SV("12345"), S("a12345bcdefghij"));
+ test(S("abcdefghij"), 1, SV("1234567890"), S("a1234567890bcdefghij"));
+ test(S("abcdefghij"), 1, SV("12345678901234567890"), S("a12345678901234567890bcdefghij"));
+ test(S("abcdefghij"), 5, SV(""), S("abcdefghij"));
+ test(S("abcdefghij"), 5, SV("12345"), S("abcde12345fghij"));
+ test(S("abcdefghij"), 5, SV("1234567890"), S("abcde1234567890fghij"));
+ test(S("abcdefghij"), 5, SV("12345678901234567890"), S("abcde12345678901234567890fghij"));
+ test(S("abcdefghij"), 9, SV(""), S("abcdefghij"));
+ test(S("abcdefghij"), 9, SV("12345"), S("abcdefghi12345j"));
+ test(S("abcdefghij"), 9, SV("1234567890"), S("abcdefghi1234567890j"));
+ test(S("abcdefghij"), 9, SV("12345678901234567890"), S("abcdefghi12345678901234567890j"));
+ test(S("abcdefghij"), 10, SV(""), S("abcdefghij"));
+ test(S("abcdefghij"), 10, SV("12345"), S("abcdefghij12345"));
+ test(S("abcdefghij"), 10, SV("1234567890"), S("abcdefghij1234567890"));
+ test(S("abcdefghij"), 10, SV("12345678901234567890"), S("abcdefghij12345678901234567890"));
+ test(S("abcdefghij"), 11, SV(""), S("can't happen"));
+ test(S("abcdefghij"), 11, SV("12345"), S("can't happen"));
+ test(S("abcdefghij"), 11, SV("1234567890"), S("can't happen"));
+ test(S("abcdefghij"), 11, SV("12345678901234567890"), S("can't happen"));
+ test(S("abcdefghijklmnopqrst"), 0, SV(""), S("abcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 0, SV("12345"), S("12345abcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 0, SV("1234567890"), S("1234567890abcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 0, SV("12345678901234567890"), S("12345678901234567890abcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 1, SV(""), S("abcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 1, SV("12345"), S("a12345bcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 1, SV("1234567890"), S("a1234567890bcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 1, SV("12345678901234567890"), S("a12345678901234567890bcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 10, SV(""), S("abcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 10, SV("12345"), S("abcdefghij12345klmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 10, SV("1234567890"), S("abcdefghij1234567890klmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 10, SV("12345678901234567890"), S("abcdefghij12345678901234567890klmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 19, SV(""), S("abcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 19, SV("12345"), S("abcdefghijklmnopqrs12345t"));
+ test(S("abcdefghijklmnopqrst"), 19, SV("1234567890"), S("abcdefghijklmnopqrs1234567890t"));
+ test(S("abcdefghijklmnopqrst"), 19, SV("12345678901234567890"), S("abcdefghijklmnopqrs12345678901234567890t"));
+ test(S("abcdefghijklmnopqrst"), 20, SV(""), S("abcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 20, SV("12345"), S("abcdefghijklmnopqrst12345"));
+ test(S("abcdefghijklmnopqrst"), 20, SV("1234567890"), S("abcdefghijklmnopqrst1234567890"));
+ test(S("abcdefghijklmnopqrst"), 20, SV("12345678901234567890"), S("abcdefghijklmnopqrst12345678901234567890"));
+ test(S("abcdefghijklmnopqrst"), 21, SV(""), S("can't happen"));
+ test(S("abcdefghijklmnopqrst"), 21, SV("12345"), S("can't happen"));
+ test(S("abcdefghijklmnopqrst"), 21, SV("1234567890"), S("can't happen"));
+ test(S("abcdefghijklmnopqrst"), 21, SV("12345678901234567890"), S("can't happen"));
+ }
+#endif
+
+ { // test inserting into self
+ typedef std::string S;
+ S s_short = "123/";
+ S s_long = "Lorem ipsum dolor sit amet, consectetur/";
+
+ s_short.insert(0, s_short.c_str());
+ assert(s_short == "123/123/");
+ s_short.insert(0, s_short.c_str());
+ assert(s_short == "123/123/123/123/");
+ s_short.insert(0, s_short.c_str());
+ assert(s_short == "123/123/123/123/123/123/123/123/");
+
+ s_long.insert(0, s_long.c_str());
+ assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
+ }
+}
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 e456d39..f8126bc 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
@@ -42,12 +42,12 @@
{
typename S::const_iterator first = s.begin() + pos1;
typename S::const_iterator last = s.begin() + pos1 + n1;
- S aCopy = s;
- try {
- s.replace(first, last, f, l);
- assert(false);
- }
- catch (...) {}
+ S aCopy = s;
+ try {
+ s.replace(first, last, f, l);
+ assert(false);
+ }
+ catch (...) {}
LIBCPP_ASSERT(s.__invariants());
assert(s == aCopy);
}
@@ -993,7 +993,7 @@
}
#endif
#ifndef TEST_HAS_NO_EXCEPTIONS
- { // test iterator operations that throw
+ { // test iterator operations that throw
typedef std::string S;
typedef ThrowingIterator<char> TIter;
typedef input_iterator<TIter> IIter;
@@ -1005,36 +1005,36 @@
test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, TIter(s, s+10, 4, TIter::TAIncrement), TIter());
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
- { // test replacing into self
+ { // test replacing into self
typedef std::string S;
- S s_short = "123/";
- S s_long = "Lorem ipsum dolor sit amet, consectetur/";
+ S s_short = "123/";
+ S s_long = "Lorem ipsum dolor sit amet, consectetur/";
- s_short.replace(s_short.begin(), s_short.begin(), s_short.begin(), s_short.end());
- assert(s_short == "123/123/");
- s_short.replace(s_short.begin(), s_short.begin(), s_short.begin(), s_short.end());
- assert(s_short == "123/123/123/123/");
- s_short.replace(s_short.begin(), s_short.begin(), s_short.begin(), s_short.end());
- assert(s_short == "123/123/123/123/123/123/123/123/");
+ s_short.replace(s_short.begin(), s_short.begin(), s_short.begin(), s_short.end());
+ assert(s_short == "123/123/");
+ s_short.replace(s_short.begin(), s_short.begin(), s_short.begin(), s_short.end());
+ assert(s_short == "123/123/123/123/");
+ s_short.replace(s_short.begin(), s_short.begin(), s_short.begin(), s_short.end());
+ assert(s_short == "123/123/123/123/123/123/123/123/");
- s_long.replace(s_long.begin(), s_long.begin(), s_long.begin(), s_long.end());
- assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
- }
+ s_long.replace(s_long.begin(), s_long.begin(), s_long.begin(), s_long.end());
+ assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
+ }
- { // test assigning a different type
+ { // test assigning a different type
typedef std::string S;
- const uint8_t pc[] = "ABCD";
- uint8_t p[] = "EFGH";
+ const uint8_t pc[] = "ABCD";
+ uint8_t p[] = "EFGH";
- S s;
- s.replace(s.begin(), s.end(), pc, pc + 4);
- assert(s == "ABCD");
+ S s;
+ s.replace(s.begin(), s.end(), pc, pc + 4);
+ assert(s == "ABCD");
- s.clear();
- s.replace(s.begin(), s.end(), p, p + 4);
- assert(s == "EFGH");
- }
+ s.clear();
+ s.replace(s.begin(), s.end(), p, p + 4);
+ assert(s == "EFGH");
+ }
}
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 f642d3a..a7d6a6e 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
@@ -283,19 +283,19 @@
}
#endif
- { // test replacing into self
+ { // test replacing into self
typedef std::string S;
- S s_short = "123/";
- S s_long = "Lorem ipsum dolor sit amet, consectetur/";
+ S s_short = "123/";
+ S s_long = "Lorem ipsum dolor sit amet, consectetur/";
- s_short.replace(s_short.begin(), s_short.begin(), s_short.c_str());
- assert(s_short == "123/123/");
- s_short.replace(s_short.begin(), s_short.begin(), s_short.c_str());
- assert(s_short == "123/123/123/123/");
- s_short.replace(s_short.begin(), s_short.begin(), s_short.c_str());
- assert(s_short == "123/123/123/123/123/123/123/123/");
+ s_short.replace(s_short.begin(), s_short.begin(), s_short.c_str());
+ assert(s_short == "123/123/");
+ s_short.replace(s_short.begin(), s_short.begin(), s_short.c_str());
+ assert(s_short == "123/123/123/123/");
+ s_short.replace(s_short.begin(), s_short.begin(), s_short.c_str());
+ assert(s_short == "123/123/123/123/123/123/123/123/");
- s_long.replace(s_long.begin(), s_long.begin(), s_long.c_str());
- assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
- }
+ s_long.replace(s_long.begin(), s_long.begin(), s_long.c_str());
+ assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
+ }
}
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 6950368..6c68b15 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
@@ -973,19 +973,19 @@
}
#endif
- { // test replacing into self
+ { // test replacing into self
typedef std::string S;
- S s_short = "123/";
- S s_long = "Lorem ipsum dolor sit amet, consectetur/";
+ S s_short = "123/";
+ S s_long = "Lorem ipsum dolor sit amet, consectetur/";
- s_short.replace(s_short.begin(), s_short.begin(), s_short.data(), s_short.size());
- assert(s_short == "123/123/");
- s_short.replace(s_short.begin(), s_short.begin(), s_short.data(), s_short.size());
- assert(s_short == "123/123/123/123/");
- s_short.replace(s_short.begin(), s_short.begin(), s_short.data(), s_short.size());
- assert(s_short == "123/123/123/123/123/123/123/123/");
+ s_short.replace(s_short.begin(), s_short.begin(), s_short.data(), s_short.size());
+ assert(s_short == "123/123/");
+ s_short.replace(s_short.begin(), s_short.begin(), s_short.data(), s_short.size());
+ assert(s_short == "123/123/123/123/");
+ s_short.replace(s_short.begin(), s_short.begin(), s_short.data(), s_short.size());
+ assert(s_short == "123/123/123/123/123/123/123/123/");
- s_long.replace(s_long.begin(), s_long.begin(), s_long.data(), s_long.size());
- assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
- }
+ s_long.replace(s_long.begin(), s_long.begin(), s_long.data(), s_long.size());
+ assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
+ }
}
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string_view.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string_view.pass.cpp
new file mode 100644
index 0000000..ec81001
--- /dev/null
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string_view.pass.cpp
@@ -0,0 +1,286 @@
+//===----------------------------------------------------------------------===//
+//
+// The 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>
+
+// basic_string<charT,traits,Allocator>&
+// replace(const_iterator i1, const_iterator i2, basic_string_view<charT,traits> sv);
+
+#include <string>
+#include <algorithm>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+template <class S, class SV>
+void
+test(S s, typename S::size_type pos1, typename S::size_type n1, SV sv, S expected)
+{
+ typename S::size_type old_size = s.size();
+ typename S::const_iterator first = s.begin() + pos1;
+ typename S::const_iterator last = s.begin() + pos1 + n1;
+ typename S::size_type xlen = last - first;
+ s.replace(first, last, sv);
+ LIBCPP_ASSERT(s.__invariants());
+ assert(s == expected);
+ typename S::size_type rlen = sv.size();
+ assert(s.size() == old_size - xlen + rlen);
+}
+
+template <class S, class SV>
+void test0()
+{
+ test(S(""), 0, 0, SV(""), S(""));
+ test(S(""), 0, 0, SV("12345"), S("12345"));
+ test(S(""), 0, 0, SV("1234567890"), S("1234567890"));
+ test(S(""), 0, 0, SV("12345678901234567890"), S("12345678901234567890"));
+ test(S("abcde"), 0, 0, SV(""), S("abcde"));
+ test(S("abcde"), 0, 0, SV("12345"), S("12345abcde"));
+ test(S("abcde"), 0, 0, SV("1234567890"), S("1234567890abcde"));
+ test(S("abcde"), 0, 0, SV("12345678901234567890"), S("12345678901234567890abcde"));
+ test(S("abcde"), 0, 1, SV(""), S("bcde"));
+ test(S("abcde"), 0, 1, SV("12345"), S("12345bcde"));
+ test(S("abcde"), 0, 1, SV("1234567890"), S("1234567890bcde"));
+ test(S("abcde"), 0, 1, SV("12345678901234567890"), S("12345678901234567890bcde"));
+ test(S("abcde"), 0, 2, SV(""), S("cde"));
+ test(S("abcde"), 0, 2, SV("12345"), S("12345cde"));
+ test(S("abcde"), 0, 2, SV("1234567890"), S("1234567890cde"));
+ test(S("abcde"), 0, 2, SV("12345678901234567890"), S("12345678901234567890cde"));
+ test(S("abcde"), 0, 4, SV(""), S("e"));
+ test(S("abcde"), 0, 4, SV("12345"), S("12345e"));
+ test(S("abcde"), 0, 4, SV("1234567890"), S("1234567890e"));
+ test(S("abcde"), 0, 4, SV("12345678901234567890"), S("12345678901234567890e"));
+ test(S("abcde"), 0, 5, SV(""), S(""));
+ test(S("abcde"), 0, 5, SV("12345"), S("12345"));
+ test(S("abcde"), 0, 5, SV("1234567890"), S("1234567890"));
+ test(S("abcde"), 0, 5, SV("12345678901234567890"), S("12345678901234567890"));
+ test(S("abcde"), 1, 0, SV(""), S("abcde"));
+ test(S("abcde"), 1, 0, SV("12345"), S("a12345bcde"));
+ test(S("abcde"), 1, 0, SV("1234567890"), S("a1234567890bcde"));
+ test(S("abcde"), 1, 0, SV("12345678901234567890"), S("a12345678901234567890bcde"));
+ test(S("abcde"), 1, 1, SV(""), S("acde"));
+ test(S("abcde"), 1, 1, SV("12345"), S("a12345cde"));
+ test(S("abcde"), 1, 1, SV("1234567890"), S("a1234567890cde"));
+ test(S("abcde"), 1, 1, SV("12345678901234567890"), S("a12345678901234567890cde"));
+ test(S("abcde"), 1, 2, SV(""), S("ade"));
+ test(S("abcde"), 1, 2, SV("12345"), S("a12345de"));
+ test(S("abcde"), 1, 2, SV("1234567890"), S("a1234567890de"));
+ test(S("abcde"), 1, 2, SV("12345678901234567890"), S("a12345678901234567890de"));
+ test(S("abcde"), 1, 3, SV(""), S("ae"));
+ test(S("abcde"), 1, 3, SV("12345"), S("a12345e"));
+ test(S("abcde"), 1, 3, SV("1234567890"), S("a1234567890e"));
+ test(S("abcde"), 1, 3, SV("12345678901234567890"), S("a12345678901234567890e"));
+ test(S("abcde"), 1, 4, SV(""), S("a"));
+ test(S("abcde"), 1, 4, SV("12345"), S("a12345"));
+ test(S("abcde"), 1, 4, SV("1234567890"), S("a1234567890"));
+ test(S("abcde"), 1, 4, SV("12345678901234567890"), S("a12345678901234567890"));
+ test(S("abcde"), 2, 0, SV(""), S("abcde"));
+ test(S("abcde"), 2, 0, SV("12345"), S("ab12345cde"));
+ test(S("abcde"), 2, 0, SV("1234567890"), S("ab1234567890cde"));
+ test(S("abcde"), 2, 0, SV("12345678901234567890"), S("ab12345678901234567890cde"));
+ test(S("abcde"), 2, 1, SV(""), S("abde"));
+ test(S("abcde"), 2, 1, SV("12345"), S("ab12345de"));
+ test(S("abcde"), 2, 1, SV("1234567890"), S("ab1234567890de"));
+ test(S("abcde"), 2, 1, SV("12345678901234567890"), S("ab12345678901234567890de"));
+ test(S("abcde"), 2, 2, SV(""), S("abe"));
+ test(S("abcde"), 2, 2, SV("12345"), S("ab12345e"));
+ test(S("abcde"), 2, 2, SV("1234567890"), S("ab1234567890e"));
+ test(S("abcde"), 2, 2, SV("12345678901234567890"), S("ab12345678901234567890e"));
+ test(S("abcde"), 2, 3, SV(""), S("ab"));
+ test(S("abcde"), 2, 3, SV("12345"), S("ab12345"));
+ test(S("abcde"), 2, 3, SV("1234567890"), S("ab1234567890"));
+ test(S("abcde"), 2, 3, SV("12345678901234567890"), S("ab12345678901234567890"));
+ test(S("abcde"), 4, 0, SV(""), S("abcde"));
+ test(S("abcde"), 4, 0, SV("12345"), S("abcd12345e"));
+ test(S("abcde"), 4, 0, SV("1234567890"), S("abcd1234567890e"));
+ test(S("abcde"), 4, 0, SV("12345678901234567890"), S("abcd12345678901234567890e"));
+ test(S("abcde"), 4, 1, SV(""), S("abcd"));
+ test(S("abcde"), 4, 1, SV("12345"), S("abcd12345"));
+ test(S("abcde"), 4, 1, SV("1234567890"), S("abcd1234567890"));
+ test(S("abcde"), 4, 1, SV("12345678901234567890"), S("abcd12345678901234567890"));
+ test(S("abcde"), 5, 0, SV(""), S("abcde"));
+ test(S("abcde"), 5, 0, SV("12345"), S("abcde12345"));
+ test(S("abcde"), 5, 0, SV("1234567890"), S("abcde1234567890"));
+ test(S("abcde"), 5, 0, SV("12345678901234567890"), S("abcde12345678901234567890"));
+ test(S("abcdefghij"), 0, 0, SV(""), S("abcdefghij"));
+ test(S("abcdefghij"), 0, 0, SV("12345"), S("12345abcdefghij"));
+ test(S("abcdefghij"), 0, 0, SV("1234567890"), S("1234567890abcdefghij"));
+ test(S("abcdefghij"), 0, 0, SV("12345678901234567890"), S("12345678901234567890abcdefghij"));
+ test(S("abcdefghij"), 0, 1, SV(""), S("bcdefghij"));
+ test(S("abcdefghij"), 0, 1, SV("12345"), S("12345bcdefghij"));
+ test(S("abcdefghij"), 0, 1, SV("1234567890"), S("1234567890bcdefghij"));
+ test(S("abcdefghij"), 0, 1, SV("12345678901234567890"), S("12345678901234567890bcdefghij"));
+ test(S("abcdefghij"), 0, 5, SV(""), S("fghij"));
+ test(S("abcdefghij"), 0, 5, SV("12345"), S("12345fghij"));
+ test(S("abcdefghij"), 0, 5, SV("1234567890"), S("1234567890fghij"));
+ test(S("abcdefghij"), 0, 5, SV("12345678901234567890"), S("12345678901234567890fghij"));
+ test(S("abcdefghij"), 0, 9, SV(""), S("j"));
+ test(S("abcdefghij"), 0, 9, SV("12345"), S("12345j"));
+ test(S("abcdefghij"), 0, 9, SV("1234567890"), S("1234567890j"));
+ test(S("abcdefghij"), 0, 9, SV("12345678901234567890"), S("12345678901234567890j"));
+ test(S("abcdefghij"), 0, 10, SV(""), S(""));
+ test(S("abcdefghij"), 0, 10, SV("12345"), S("12345"));
+ test(S("abcdefghij"), 0, 10, SV("1234567890"), S("1234567890"));
+ test(S("abcdefghij"), 0, 10, SV("12345678901234567890"), S("12345678901234567890"));
+ test(S("abcdefghij"), 1, 0, SV(""), S("abcdefghij"));
+ test(S("abcdefghij"), 1, 0, SV("12345"), S("a12345bcdefghij"));
+ test(S("abcdefghij"), 1, 0, SV("1234567890"), S("a1234567890bcdefghij"));
+ test(S("abcdefghij"), 1, 0, SV("12345678901234567890"), S("a12345678901234567890bcdefghij"));
+ test(S("abcdefghij"), 1, 1, SV(""), S("acdefghij"));
+ test(S("abcdefghij"), 1, 1, SV("12345"), S("a12345cdefghij"));
+ test(S("abcdefghij"), 1, 1, SV("1234567890"), S("a1234567890cdefghij"));
+ test(S("abcdefghij"), 1, 1, SV("12345678901234567890"), S("a12345678901234567890cdefghij"));
+}
+
+template <class S, class SV>
+void test1()
+{
+ test(S("abcdefghij"), 1, 4, SV(""), S("afghij"));
+ test(S("abcdefghij"), 1, 4, SV("12345"), S("a12345fghij"));
+ test(S("abcdefghij"), 1, 4, SV("1234567890"), S("a1234567890fghij"));
+ test(S("abcdefghij"), 1, 4, SV("12345678901234567890"), S("a12345678901234567890fghij"));
+ test(S("abcdefghij"), 1, 8, SV(""), S("aj"));
+ test(S("abcdefghij"), 1, 8, SV("12345"), S("a12345j"));
+ test(S("abcdefghij"), 1, 8, SV("1234567890"), S("a1234567890j"));
+ test(S("abcdefghij"), 1, 8, SV("12345678901234567890"), S("a12345678901234567890j"));
+ test(S("abcdefghij"), 1, 9, SV(""), S("a"));
+ test(S("abcdefghij"), 1, 9, SV("12345"), S("a12345"));
+ test(S("abcdefghij"), 1, 9, SV("1234567890"), S("a1234567890"));
+ test(S("abcdefghij"), 1, 9, SV("12345678901234567890"), S("a12345678901234567890"));
+ test(S("abcdefghij"), 5, 0, SV(""), S("abcdefghij"));
+ test(S("abcdefghij"), 5, 0, SV("12345"), S("abcde12345fghij"));
+ test(S("abcdefghij"), 5, 0, SV("1234567890"), S("abcde1234567890fghij"));
+ test(S("abcdefghij"), 5, 0, SV("12345678901234567890"), S("abcde12345678901234567890fghij"));
+ test(S("abcdefghij"), 5, 1, SV(""), S("abcdeghij"));
+ test(S("abcdefghij"), 5, 1, SV("12345"), S("abcde12345ghij"));
+ test(S("abcdefghij"), 5, 1, SV("1234567890"), S("abcde1234567890ghij"));
+ test(S("abcdefghij"), 5, 1, SV("12345678901234567890"), S("abcde12345678901234567890ghij"));
+ test(S("abcdefghij"), 5, 2, SV(""), S("abcdehij"));
+ test(S("abcdefghij"), 5, 2, SV("12345"), S("abcde12345hij"));
+ test(S("abcdefghij"), 5, 2, SV("1234567890"), S("abcde1234567890hij"));
+ test(S("abcdefghij"), 5, 2, SV("12345678901234567890"), S("abcde12345678901234567890hij"));
+ test(S("abcdefghij"), 5, 4, SV(""), S("abcdej"));
+ test(S("abcdefghij"), 5, 4, SV("12345"), S("abcde12345j"));
+ test(S("abcdefghij"), 5, 4, SV("1234567890"), S("abcde1234567890j"));
+ test(S("abcdefghij"), 5, 4, SV("12345678901234567890"), S("abcde12345678901234567890j"));
+ test(S("abcdefghij"), 5, 5, SV(""), S("abcde"));
+ test(S("abcdefghij"), 5, 5, SV("12345"), S("abcde12345"));
+ test(S("abcdefghij"), 5, 5, SV("1234567890"), S("abcde1234567890"));
+ test(S("abcdefghij"), 5, 5, SV("12345678901234567890"), S("abcde12345678901234567890"));
+ test(S("abcdefghij"), 9, 0, SV(""), S("abcdefghij"));
+ test(S("abcdefghij"), 9, 0, SV("12345"), S("abcdefghi12345j"));
+ test(S("abcdefghij"), 9, 0, SV("1234567890"), S("abcdefghi1234567890j"));
+ test(S("abcdefghij"), 9, 0, SV("12345678901234567890"), S("abcdefghi12345678901234567890j"));
+ test(S("abcdefghij"), 9, 1, SV(""), S("abcdefghi"));
+ test(S("abcdefghij"), 9, 1, SV("12345"), S("abcdefghi12345"));
+ test(S("abcdefghij"), 9, 1, SV("1234567890"), S("abcdefghi1234567890"));
+ test(S("abcdefghij"), 9, 1, SV("12345678901234567890"), S("abcdefghi12345678901234567890"));
+ test(S("abcdefghij"), 10, 0, SV(""), S("abcdefghij"));
+ test(S("abcdefghij"), 10, 0, SV("12345"), S("abcdefghij12345"));
+ test(S("abcdefghij"), 10, 0, SV("1234567890"), S("abcdefghij1234567890"));
+ test(S("abcdefghij"), 10, 0, SV("12345678901234567890"), S("abcdefghij12345678901234567890"));
+ test(S("abcdefghijklmnopqrst"), 0, 0, SV(""), S("abcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 0, 0, SV("12345"), S("12345abcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 0, 0, SV("1234567890"), S("1234567890abcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 0, 0, SV("12345678901234567890"), S("12345678901234567890abcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 0, 1, SV(""), S("bcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 0, 1, SV("12345"), S("12345bcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 0, 1, SV("1234567890"), S("1234567890bcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 0, 1, SV("12345678901234567890"), S("12345678901234567890bcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 0, 10, SV(""), S("klmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 0, 10, SV("12345"), S("12345klmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 0, 10, SV("1234567890"), S("1234567890klmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 0, 10, SV("12345678901234567890"), S("12345678901234567890klmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 0, 19, SV(""), S("t"));
+ test(S("abcdefghijklmnopqrst"), 0, 19, SV("12345"), S("12345t"));
+ test(S("abcdefghijklmnopqrst"), 0, 19, SV("1234567890"), S("1234567890t"));
+ test(S("abcdefghijklmnopqrst"), 0, 19, SV("12345678901234567890"), S("12345678901234567890t"));
+ test(S("abcdefghijklmnopqrst"), 0, 20, SV(""), S(""));
+ test(S("abcdefghijklmnopqrst"), 0, 20, SV("12345"), S("12345"));
+ test(S("abcdefghijklmnopqrst"), 0, 20, SV("1234567890"), S("1234567890"));
+ test(S("abcdefghijklmnopqrst"), 0, 20, SV("12345678901234567890"), S("12345678901234567890"));
+ test(S("abcdefghijklmnopqrst"), 1, 0, SV(""), S("abcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 1, 0, SV("12345"), S("a12345bcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 1, 0, SV("1234567890"), S("a1234567890bcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 1, 0, SV("12345678901234567890"), S("a12345678901234567890bcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 1, 1, SV(""), S("acdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 1, 1, SV("12345"), S("a12345cdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 1, 1, SV("1234567890"), S("a1234567890cdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 1, 1, SV("12345678901234567890"), S("a12345678901234567890cdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 1, 9, SV(""), S("aklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 1, 9, SV("12345"), S("a12345klmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 1, 9, SV("1234567890"), S("a1234567890klmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 1, 9, SV("12345678901234567890"), S("a12345678901234567890klmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 1, 18, SV(""), S("at"));
+ test(S("abcdefghijklmnopqrst"), 1, 18, SV("12345"), S("a12345t"));
+ test(S("abcdefghijklmnopqrst"), 1, 18, SV("1234567890"), S("a1234567890t"));
+ test(S("abcdefghijklmnopqrst"), 1, 18, SV("12345678901234567890"), S("a12345678901234567890t"));
+ test(S("abcdefghijklmnopqrst"), 1, 19, SV(""), S("a"));
+ test(S("abcdefghijklmnopqrst"), 1, 19, SV("12345"), S("a12345"));
+ test(S("abcdefghijklmnopqrst"), 1, 19, SV("1234567890"), S("a1234567890"));
+ test(S("abcdefghijklmnopqrst"), 1, 19, SV("12345678901234567890"), S("a12345678901234567890"));
+ test(S("abcdefghijklmnopqrst"), 10, 0, SV(""), S("abcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 10, 0, SV("12345"), S("abcdefghij12345klmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 10, 0, SV("1234567890"), S("abcdefghij1234567890klmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 10, 0, SV("12345678901234567890"), S("abcdefghij12345678901234567890klmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 10, 1, SV(""), S("abcdefghijlmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 10, 1, SV("12345"), S("abcdefghij12345lmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 10, 1, SV("1234567890"), S("abcdefghij1234567890lmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 10, 1, SV("12345678901234567890"), S("abcdefghij12345678901234567890lmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 10, 5, SV(""), S("abcdefghijpqrst"));
+ test(S("abcdefghijklmnopqrst"), 10, 5, SV("12345"), S("abcdefghij12345pqrst"));
+ test(S("abcdefghijklmnopqrst"), 10, 5, SV("1234567890"), S("abcdefghij1234567890pqrst"));
+ test(S("abcdefghijklmnopqrst"), 10, 5, SV("12345678901234567890"), S("abcdefghij12345678901234567890pqrst"));
+ test(S("abcdefghijklmnopqrst"), 10, 9, SV(""), S("abcdefghijt"));
+ test(S("abcdefghijklmnopqrst"), 10, 9, SV("12345"), S("abcdefghij12345t"));
+ test(S("abcdefghijklmnopqrst"), 10, 9, SV("1234567890"), S("abcdefghij1234567890t"));
+ test(S("abcdefghijklmnopqrst"), 10, 9, SV("12345678901234567890"), S("abcdefghij12345678901234567890t"));
+}
+
+template <class S, class SV>
+void test2()
+{
+ test(S("abcdefghijklmnopqrst"), 10, 10, SV(""), S("abcdefghij"));
+ test(S("abcdefghijklmnopqrst"), 10, 10, SV("12345"), S("abcdefghij12345"));
+ test(S("abcdefghijklmnopqrst"), 10, 10, SV("1234567890"), S("abcdefghij1234567890"));
+ test(S("abcdefghijklmnopqrst"), 10, 10, SV("12345678901234567890"), S("abcdefghij12345678901234567890"));
+ test(S("abcdefghijklmnopqrst"), 19, 0, SV(""), S("abcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 19, 0, SV("12345"), S("abcdefghijklmnopqrs12345t"));
+ test(S("abcdefghijklmnopqrst"), 19, 0, SV("1234567890"), S("abcdefghijklmnopqrs1234567890t"));
+ test(S("abcdefghijklmnopqrst"), 19, 0, SV("12345678901234567890"), S("abcdefghijklmnopqrs12345678901234567890t"));
+ test(S("abcdefghijklmnopqrst"), 19, 1, SV(""), S("abcdefghijklmnopqrs"));
+ test(S("abcdefghijklmnopqrst"), 19, 1, SV("12345"), S("abcdefghijklmnopqrs12345"));
+ test(S("abcdefghijklmnopqrst"), 19, 1, SV("1234567890"), S("abcdefghijklmnopqrs1234567890"));
+ test(S("abcdefghijklmnopqrst"), 19, 1, SV("12345678901234567890"), S("abcdefghijklmnopqrs12345678901234567890"));
+ test(S("abcdefghijklmnopqrst"), 20, 0, SV(""), S("abcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 20, 0, SV("12345"), S("abcdefghijklmnopqrst12345"));
+ test(S("abcdefghijklmnopqrst"), 20, 0, SV("1234567890"), S("abcdefghijklmnopqrst1234567890"));
+ test(S("abcdefghijklmnopqrst"), 20, 0, SV("12345678901234567890"), S("abcdefghijklmnopqrst12345678901234567890"));
+}
+
+int main()
+{
+ {
+ typedef std::string S;
+ typedef std::string_view SV;
+ test0<S, SV>();
+ test1<S, SV>();
+ test2<S, SV>();
+ }
+#if TEST_STD_VER >= 11
+ {
+ typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+ typedef std::string_view SV;
+ test0<S, SV>();
+ test1<S, SV>();
+ test2<S, SV>();
+ }
+#endif
+}
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_view.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_view.pass.cpp
new file mode 100644
index 0000000..60ecd67
--- /dev/null
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_view.pass.cpp
@@ -0,0 +1,384 @@
+//===----------------------------------------------------------------------===//
+//
+// The 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>
+
+// basic_string<charT,traits,Allocator>&
+// replace(size_type pos1, size_type n1, basic_string_view<charT,traits> sv);
+
+#include <string>
+#include <stdexcept>
+#include <algorithm>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+template <class S, class SV>
+void
+test(S s, typename S::size_type pos1, typename S::size_type n1, SV sv, S expected)
+{
+ const typename S::size_type old_size = s.size();
+ S s0 = s;
+ if (pos1 <= old_size)
+ {
+ s.replace(pos1, n1, sv);
+ LIBCPP_ASSERT(s.__invariants());
+ assert(s == expected);
+ typename S::size_type xlen = std::min(n1, old_size - pos1);
+ typename S::size_type rlen = sv.size();
+ assert(s.size() == old_size - xlen + rlen);
+ }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+ else
+ {
+ try
+ {
+ s.replace(pos1, n1, sv);
+ assert(false);
+ }
+ catch (std::out_of_range&)
+ {
+ assert(pos1 > old_size);
+ assert(s == s0);
+ }
+ }
+#endif
+}
+
+template <class S, class SV>
+void test0()
+{
+ test(S(""), 0, 0, SV(""), S(""));
+ test(S(""), 0, 0, SV("12345"), S("12345"));
+ test(S(""), 0, 0, SV("1234567890"), S("1234567890"));
+ test(S(""), 0, 0, SV("12345678901234567890"), S("12345678901234567890"));
+ test(S(""), 0, 1, SV(""), S(""));
+ test(S(""), 0, 1, SV("12345"), S("12345"));
+ test(S(""), 0, 1, SV("1234567890"), S("1234567890"));
+ test(S(""), 0, 1, SV("12345678901234567890"), S("12345678901234567890"));
+ test(S(""), 1, 0, SV(""), S("can't happen"));
+ test(S(""), 1, 0, SV("12345"), S("can't happen"));
+ test(S(""), 1, 0, SV("1234567890"), S("can't happen"));
+ test(S(""), 1, 0, SV("12345678901234567890"), S("can't happen"));
+ test(S("abcde"), 0, 0, SV(""), S("abcde"));
+ test(S("abcde"), 0, 0, SV("12345"), S("12345abcde"));
+ test(S("abcde"), 0, 0, SV("1234567890"), S("1234567890abcde"));
+ test(S("abcde"), 0, 0, SV("12345678901234567890"), S("12345678901234567890abcde"));
+ test(S("abcde"), 0, 1, SV(""), S("bcde"));
+ test(S("abcde"), 0, 1, SV("12345"), S("12345bcde"));
+ test(S("abcde"), 0, 1, SV("1234567890"), S("1234567890bcde"));
+ test(S("abcde"), 0, 1, SV("12345678901234567890"), S("12345678901234567890bcde"));
+ test(S("abcde"), 0, 2, SV(""), S("cde"));
+ test(S("abcde"), 0, 2, SV("12345"), S("12345cde"));
+ test(S("abcde"), 0, 2, SV("1234567890"), S("1234567890cde"));
+ test(S("abcde"), 0, 2, SV("12345678901234567890"), S("12345678901234567890cde"));
+ test(S("abcde"), 0, 4, SV(""), S("e"));
+ test(S("abcde"), 0, 4, SV("12345"), S("12345e"));
+ test(S("abcde"), 0, 4, SV("1234567890"), S("1234567890e"));
+ test(S("abcde"), 0, 4, SV("12345678901234567890"), S("12345678901234567890e"));
+ test(S("abcde"), 0, 5, SV(""), S(""));
+ test(S("abcde"), 0, 5, SV("12345"), S("12345"));
+ test(S("abcde"), 0, 5, SV("1234567890"), S("1234567890"));
+ test(S("abcde"), 0, 5, SV("12345678901234567890"), S("12345678901234567890"));
+ test(S("abcde"), 0, 6, SV(""), S(""));
+ test(S("abcde"), 0, 6, SV("12345"), S("12345"));
+ test(S("abcde"), 0, 6, SV("1234567890"), S("1234567890"));
+ test(S("abcde"), 0, 6, SV("12345678901234567890"), S("12345678901234567890"));
+ test(S("abcde"), 1, 0, SV(""), S("abcde"));
+ test(S("abcde"), 1, 0, SV("12345"), S("a12345bcde"));
+ test(S("abcde"), 1, 0, SV("1234567890"), S("a1234567890bcde"));
+ test(S("abcde"), 1, 0, SV("12345678901234567890"), S("a12345678901234567890bcde"));
+ test(S("abcde"), 1, 1, SV(""), S("acde"));
+ test(S("abcde"), 1, 1, SV("12345"), S("a12345cde"));
+ test(S("abcde"), 1, 1, SV("1234567890"), S("a1234567890cde"));
+ test(S("abcde"), 1, 1, SV("12345678901234567890"), S("a12345678901234567890cde"));
+ test(S("abcde"), 1, 2, SV(""), S("ade"));
+ test(S("abcde"), 1, 2, SV("12345"), S("a12345de"));
+ test(S("abcde"), 1, 2, SV("1234567890"), S("a1234567890de"));
+ test(S("abcde"), 1, 2, SV("12345678901234567890"), S("a12345678901234567890de"));
+ test(S("abcde"), 1, 3, SV(""), S("ae"));
+ test(S("abcde"), 1, 3, SV("12345"), S("a12345e"));
+ test(S("abcde"), 1, 3, SV("1234567890"), S("a1234567890e"));
+ test(S("abcde"), 1, 3, SV("12345678901234567890"), S("a12345678901234567890e"));
+ test(S("abcde"), 1, 4, SV(""), S("a"));
+ test(S("abcde"), 1, 4, SV("12345"), S("a12345"));
+ test(S("abcde"), 1, 4, SV("1234567890"), S("a1234567890"));
+ test(S("abcde"), 1, 4, SV("12345678901234567890"), S("a12345678901234567890"));
+ test(S("abcde"), 1, 5, SV(""), S("a"));
+ test(S("abcde"), 1, 5, SV("12345"), S("a12345"));
+ test(S("abcde"), 1, 5, SV("1234567890"), S("a1234567890"));
+ test(S("abcde"), 1, 5, SV("12345678901234567890"), S("a12345678901234567890"));
+ test(S("abcde"), 2, 0, SV(""), S("abcde"));
+ test(S("abcde"), 2, 0, SV("12345"), S("ab12345cde"));
+ test(S("abcde"), 2, 0, SV("1234567890"), S("ab1234567890cde"));
+ test(S("abcde"), 2, 0, SV("12345678901234567890"), S("ab12345678901234567890cde"));
+ test(S("abcde"), 2, 1, SV(""), S("abde"));
+ test(S("abcde"), 2, 1, SV("12345"), S("ab12345de"));
+ test(S("abcde"), 2, 1, SV("1234567890"), S("ab1234567890de"));
+ test(S("abcde"), 2, 1, SV("12345678901234567890"), S("ab12345678901234567890de"));
+ test(S("abcde"), 2, 2, SV(""), S("abe"));
+ test(S("abcde"), 2, 2, SV("12345"), S("ab12345e"));
+ test(S("abcde"), 2, 2, SV("1234567890"), S("ab1234567890e"));
+ test(S("abcde"), 2, 2, SV("12345678901234567890"), S("ab12345678901234567890e"));
+ test(S("abcde"), 2, 3, SV(""), S("ab"));
+ test(S("abcde"), 2, 3, SV("12345"), S("ab12345"));
+ test(S("abcde"), 2, 3, SV("1234567890"), S("ab1234567890"));
+ test(S("abcde"), 2, 3, SV("12345678901234567890"), S("ab12345678901234567890"));
+ test(S("abcde"), 2, 4, SV(""), S("ab"));
+ test(S("abcde"), 2, 4, SV("12345"), S("ab12345"));
+ test(S("abcde"), 2, 4, SV("1234567890"), S("ab1234567890"));
+ test(S("abcde"), 2, 4, SV("12345678901234567890"), S("ab12345678901234567890"));
+ test(S("abcde"), 4, 0, SV(""), S("abcde"));
+ test(S("abcde"), 4, 0, SV("12345"), S("abcd12345e"));
+ test(S("abcde"), 4, 0, SV("1234567890"), S("abcd1234567890e"));
+ test(S("abcde"), 4, 0, SV("12345678901234567890"), S("abcd12345678901234567890e"));
+ test(S("abcde"), 4, 1, SV(""), S("abcd"));
+ test(S("abcde"), 4, 1, SV("12345"), S("abcd12345"));
+ test(S("abcde"), 4, 1, SV("1234567890"), S("abcd1234567890"));
+ test(S("abcde"), 4, 1, SV("12345678901234567890"), S("abcd12345678901234567890"));
+ test(S("abcde"), 4, 2, SV(""), S("abcd"));
+ test(S("abcde"), 4, 2, SV("12345"), S("abcd12345"));
+ test(S("abcde"), 4, 2, SV("1234567890"), S("abcd1234567890"));
+ test(S("abcde"), 4, 2, SV("12345678901234567890"), S("abcd12345678901234567890"));
+ test(S("abcde"), 5, 0, SV(""), S("abcde"));
+ test(S("abcde"), 5, 0, SV("12345"), S("abcde12345"));
+ test(S("abcde"), 5, 0, SV("1234567890"), S("abcde1234567890"));
+ test(S("abcde"), 5, 0, SV("12345678901234567890"), S("abcde12345678901234567890"));
+ test(S("abcde"), 5, 1, SV(""), S("abcde"));
+ test(S("abcde"), 5, 1, SV("12345"), S("abcde12345"));
+ test(S("abcde"), 5, 1, SV("1234567890"), S("abcde1234567890"));
+ test(S("abcde"), 5, 1, SV("12345678901234567890"), S("abcde12345678901234567890"));
+}
+
+template <class S, class SV>
+void test1()
+{
+ test(S("abcde"), 6, 0, SV(""), S("can't happen"));
+ test(S("abcde"), 6, 0, SV("12345"), S("can't happen"));
+ test(S("abcde"), 6, 0, SV("1234567890"), S("can't happen"));
+ test(S("abcde"), 6, 0, SV("12345678901234567890"), S("can't happen"));
+ test(S("abcdefghij"), 0, 0, SV(""), S("abcdefghij"));
+ test(S("abcdefghij"), 0, 0, SV("12345"), S("12345abcdefghij"));
+ test(S("abcdefghij"), 0, 0, SV("1234567890"), S("1234567890abcdefghij"));
+ test(S("abcdefghij"), 0, 0, SV("12345678901234567890"), S("12345678901234567890abcdefghij"));
+ test(S("abcdefghij"), 0, 1, SV(""), S("bcdefghij"));
+ test(S("abcdefghij"), 0, 1, SV("12345"), S("12345bcdefghij"));
+ test(S("abcdefghij"), 0, 1, SV("1234567890"), S("1234567890bcdefghij"));
+ test(S("abcdefghij"), 0, 1, SV("12345678901234567890"), S("12345678901234567890bcdefghij"));
+ test(S("abcdefghij"), 0, 5, SV(""), S("fghij"));
+ test(S("abcdefghij"), 0, 5, SV("12345"), S("12345fghij"));
+ test(S("abcdefghij"), 0, 5, SV("1234567890"), S("1234567890fghij"));
+ test(S("abcdefghij"), 0, 5, SV("12345678901234567890"), S("12345678901234567890fghij"));
+ test(S("abcdefghij"), 0, 9, SV(""), S("j"));
+ test(S("abcdefghij"), 0, 9, SV("12345"), S("12345j"));
+ test(S("abcdefghij"), 0, 9, SV("1234567890"), S("1234567890j"));
+ test(S("abcdefghij"), 0, 9, SV("12345678901234567890"), S("12345678901234567890j"));
+ test(S("abcdefghij"), 0, 10, SV(""), S(""));
+ test(S("abcdefghij"), 0, 10, SV("12345"), S("12345"));
+ test(S("abcdefghij"), 0, 10, SV("1234567890"), S("1234567890"));
+ test(S("abcdefghij"), 0, 10, SV("12345678901234567890"), S("12345678901234567890"));
+ test(S("abcdefghij"), 0, 11, SV(""), S(""));
+ test(S("abcdefghij"), 0, 11, SV("12345"), S("12345"));
+ test(S("abcdefghij"), 0, 11, SV("1234567890"), S("1234567890"));
+ test(S("abcdefghij"), 0, 11, SV("12345678901234567890"), S("12345678901234567890"));
+ test(S("abcdefghij"), 1, 0, SV(""), S("abcdefghij"));
+ test(S("abcdefghij"), 1, 0, SV("12345"), S("a12345bcdefghij"));
+ test(S("abcdefghij"), 1, 0, SV("1234567890"), S("a1234567890bcdefghij"));
+ test(S("abcdefghij"), 1, 0, SV("12345678901234567890"), S("a12345678901234567890bcdefghij"));
+ test(S("abcdefghij"), 1, 1, SV(""), S("acdefghij"));
+ test(S("abcdefghij"), 1, 1, SV("12345"), S("a12345cdefghij"));
+ test(S("abcdefghij"), 1, 1, SV("1234567890"), S("a1234567890cdefghij"));
+ test(S("abcdefghij"), 1, 1, SV("12345678901234567890"), S("a12345678901234567890cdefghij"));
+ test(S("abcdefghij"), 1, 4, SV(""), S("afghij"));
+ test(S("abcdefghij"), 1, 4, SV("12345"), S("a12345fghij"));
+ test(S("abcdefghij"), 1, 4, SV("1234567890"), S("a1234567890fghij"));
+ test(S("abcdefghij"), 1, 4, SV("12345678901234567890"), S("a12345678901234567890fghij"));
+ test(S("abcdefghij"), 1, 8, SV(""), S("aj"));
+ test(S("abcdefghij"), 1, 8, SV("12345"), S("a12345j"));
+ test(S("abcdefghij"), 1, 8, SV("1234567890"), S("a1234567890j"));
+ test(S("abcdefghij"), 1, 8, SV("12345678901234567890"), S("a12345678901234567890j"));
+ test(S("abcdefghij"), 1, 9, SV(""), S("a"));
+ test(S("abcdefghij"), 1, 9, SV("12345"), S("a12345"));
+ test(S("abcdefghij"), 1, 9, SV("1234567890"), S("a1234567890"));
+ test(S("abcdefghij"), 1, 9, SV("12345678901234567890"), S("a12345678901234567890"));
+ test(S("abcdefghij"), 1, 10, SV(""), S("a"));
+ test(S("abcdefghij"), 1, 10, SV("12345"), S("a12345"));
+ test(S("abcdefghij"), 1, 10, SV("1234567890"), S("a1234567890"));
+ test(S("abcdefghij"), 1, 10, SV("12345678901234567890"), S("a12345678901234567890"));
+ test(S("abcdefghij"), 5, 0, SV(""), S("abcdefghij"));
+ test(S("abcdefghij"), 5, 0, SV("12345"), S("abcde12345fghij"));
+ test(S("abcdefghij"), 5, 0, SV("1234567890"), S("abcde1234567890fghij"));
+ test(S("abcdefghij"), 5, 0, SV("12345678901234567890"), S("abcde12345678901234567890fghij"));
+ test(S("abcdefghij"), 5, 1, SV(""), S("abcdeghij"));
+ test(S("abcdefghij"), 5, 1, SV("12345"), S("abcde12345ghij"));
+ test(S("abcdefghij"), 5, 1, SV("1234567890"), S("abcde1234567890ghij"));
+ test(S("abcdefghij"), 5, 1, SV("12345678901234567890"), S("abcde12345678901234567890ghij"));
+ test(S("abcdefghij"), 5, 2, SV(""), S("abcdehij"));
+ test(S("abcdefghij"), 5, 2, SV("12345"), S("abcde12345hij"));
+ test(S("abcdefghij"), 5, 2, SV("1234567890"), S("abcde1234567890hij"));
+ test(S("abcdefghij"), 5, 2, SV("12345678901234567890"), S("abcde12345678901234567890hij"));
+ test(S("abcdefghij"), 5, 4, SV(""), S("abcdej"));
+ test(S("abcdefghij"), 5, 4, SV("12345"), S("abcde12345j"));
+ test(S("abcdefghij"), 5, 4, SV("1234567890"), S("abcde1234567890j"));
+ test(S("abcdefghij"), 5, 4, SV("12345678901234567890"), S("abcde12345678901234567890j"));
+ test(S("abcdefghij"), 5, 5, SV(""), S("abcde"));
+ test(S("abcdefghij"), 5, 5, SV("12345"), S("abcde12345"));
+ test(S("abcdefghij"), 5, 5, SV("1234567890"), S("abcde1234567890"));
+ test(S("abcdefghij"), 5, 5, SV("12345678901234567890"), S("abcde12345678901234567890"));
+ test(S("abcdefghij"), 5, 6, SV(""), S("abcde"));
+ test(S("abcdefghij"), 5, 6, SV("12345"), S("abcde12345"));
+ test(S("abcdefghij"), 5, 6, SV("1234567890"), S("abcde1234567890"));
+ test(S("abcdefghij"), 5, 6, SV("12345678901234567890"), S("abcde12345678901234567890"));
+ test(S("abcdefghij"), 9, 0, SV(""), S("abcdefghij"));
+ test(S("abcdefghij"), 9, 0, SV("12345"), S("abcdefghi12345j"));
+ test(S("abcdefghij"), 9, 0, SV("1234567890"), S("abcdefghi1234567890j"));
+ test(S("abcdefghij"), 9, 0, SV("12345678901234567890"), S("abcdefghi12345678901234567890j"));
+ test(S("abcdefghij"), 9, 1, SV(""), S("abcdefghi"));
+ test(S("abcdefghij"), 9, 1, SV("12345"), S("abcdefghi12345"));
+ test(S("abcdefghij"), 9, 1, SV("1234567890"), S("abcdefghi1234567890"));
+ test(S("abcdefghij"), 9, 1, SV("12345678901234567890"), S("abcdefghi12345678901234567890"));
+ test(S("abcdefghij"), 9, 2, SV(""), S("abcdefghi"));
+ test(S("abcdefghij"), 9, 2, SV("12345"), S("abcdefghi12345"));
+ test(S("abcdefghij"), 9, 2, SV("1234567890"), S("abcdefghi1234567890"));
+ test(S("abcdefghij"), 9, 2, SV("12345678901234567890"), S("abcdefghi12345678901234567890"));
+ test(S("abcdefghij"), 10, 0, SV(""), S("abcdefghij"));
+ test(S("abcdefghij"), 10, 0, SV("12345"), S("abcdefghij12345"));
+ test(S("abcdefghij"), 10, 0, SV("1234567890"), S("abcdefghij1234567890"));
+ test(S("abcdefghij"), 10, 0, SV("12345678901234567890"), S("abcdefghij12345678901234567890"));
+ test(S("abcdefghij"), 10, 1, SV(""), S("abcdefghij"));
+ test(S("abcdefghij"), 10, 1, SV("12345"), S("abcdefghij12345"));
+ test(S("abcdefghij"), 10, 1, SV("1234567890"), S("abcdefghij1234567890"));
+ test(S("abcdefghij"), 10, 1, SV("12345678901234567890"), S("abcdefghij12345678901234567890"));
+ test(S("abcdefghij"), 11, 0, SV(""), S("can't happen"));
+ test(S("abcdefghij"), 11, 0, SV("12345"), S("can't happen"));
+ test(S("abcdefghij"), 11, 0, SV("1234567890"), S("can't happen"));
+ test(S("abcdefghij"), 11, 0, SV("12345678901234567890"), S("can't happen"));
+}
+
+template <class S, class SV>
+void test2()
+{
+ test(S("abcdefghijklmnopqrst"), 0, 0, SV(""), S("abcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 0, 0, SV("12345"), S("12345abcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 0, 0, SV("1234567890"), S("1234567890abcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 0, 0, SV("12345678901234567890"), S("12345678901234567890abcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 0, 1, SV(""), S("bcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 0, 1, SV("12345"), S("12345bcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 0, 1, SV("1234567890"), S("1234567890bcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 0, 1, SV("12345678901234567890"), S("12345678901234567890bcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 0, 10, SV(""), S("klmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 0, 10, SV("12345"), S("12345klmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 0, 10, SV("1234567890"), S("1234567890klmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 0, 10, SV("12345678901234567890"), S("12345678901234567890klmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 0, 19, SV(""), S("t"));
+ test(S("abcdefghijklmnopqrst"), 0, 19, SV("12345"), S("12345t"));
+ test(S("abcdefghijklmnopqrst"), 0, 19, SV("1234567890"), S("1234567890t"));
+ test(S("abcdefghijklmnopqrst"), 0, 19, SV("12345678901234567890"), S("12345678901234567890t"));
+ test(S("abcdefghijklmnopqrst"), 0, 20, SV(""), S(""));
+ test(S("abcdefghijklmnopqrst"), 0, 20, SV("12345"), S("12345"));
+ test(S("abcdefghijklmnopqrst"), 0, 20, SV("1234567890"), S("1234567890"));
+ test(S("abcdefghijklmnopqrst"), 0, 20, SV("12345678901234567890"), S("12345678901234567890"));
+ test(S("abcdefghijklmnopqrst"), 0, 21, SV(""), S(""));
+ test(S("abcdefghijklmnopqrst"), 0, 21, SV("12345"), S("12345"));
+ test(S("abcdefghijklmnopqrst"), 0, 21, SV("1234567890"), S("1234567890"));
+ test(S("abcdefghijklmnopqrst"), 0, 21, SV("12345678901234567890"), S("12345678901234567890"));
+ test(S("abcdefghijklmnopqrst"), 1, 0, SV(""), S("abcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 1, 0, SV("12345"), S("a12345bcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 1, 0, SV("1234567890"), S("a1234567890bcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 1, 0, SV("12345678901234567890"), S("a12345678901234567890bcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 1, 1, SV(""), S("acdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 1, 1, SV("12345"), S("a12345cdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 1, 1, SV("1234567890"), S("a1234567890cdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 1, 1, SV("12345678901234567890"), S("a12345678901234567890cdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 1, 9, SV(""), S("aklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 1, 9, SV("12345"), S("a12345klmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 1, 9, SV("1234567890"), S("a1234567890klmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 1, 9, SV("12345678901234567890"), S("a12345678901234567890klmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 1, 18, SV(""), S("at"));
+ test(S("abcdefghijklmnopqrst"), 1, 18, SV("12345"), S("a12345t"));
+ test(S("abcdefghijklmnopqrst"), 1, 18, SV("1234567890"), S("a1234567890t"));
+ test(S("abcdefghijklmnopqrst"), 1, 18, SV("12345678901234567890"), S("a12345678901234567890t"));
+ test(S("abcdefghijklmnopqrst"), 1, 19, SV(""), S("a"));
+ test(S("abcdefghijklmnopqrst"), 1, 19, SV("12345"), S("a12345"));
+ test(S("abcdefghijklmnopqrst"), 1, 19, SV("1234567890"), S("a1234567890"));
+ test(S("abcdefghijklmnopqrst"), 1, 19, SV("12345678901234567890"), S("a12345678901234567890"));
+ test(S("abcdefghijklmnopqrst"), 1, 20, SV(""), S("a"));
+ test(S("abcdefghijklmnopqrst"), 1, 20, SV("12345"), S("a12345"));
+ test(S("abcdefghijklmnopqrst"), 1, 20, SV("1234567890"), S("a1234567890"));
+ test(S("abcdefghijklmnopqrst"), 1, 20, SV("12345678901234567890"), S("a12345678901234567890"));
+ test(S("abcdefghijklmnopqrst"), 10, 0, SV(""), S("abcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 10, 0, SV("12345"), S("abcdefghij12345klmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 10, 0, SV("1234567890"), S("abcdefghij1234567890klmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 10, 0, SV("12345678901234567890"), S("abcdefghij12345678901234567890klmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 10, 1, SV(""), S("abcdefghijlmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 10, 1, SV("12345"), S("abcdefghij12345lmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 10, 1, SV("1234567890"), S("abcdefghij1234567890lmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 10, 1, SV("12345678901234567890"), S("abcdefghij12345678901234567890lmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 10, 5, SV(""), S("abcdefghijpqrst"));
+ test(S("abcdefghijklmnopqrst"), 10, 5, SV("12345"), S("abcdefghij12345pqrst"));
+ test(S("abcdefghijklmnopqrst"), 10, 5, SV("1234567890"), S("abcdefghij1234567890pqrst"));
+ test(S("abcdefghijklmnopqrst"), 10, 5, SV("12345678901234567890"), S("abcdefghij12345678901234567890pqrst"));
+ test(S("abcdefghijklmnopqrst"), 10, 9, SV(""), S("abcdefghijt"));
+ test(S("abcdefghijklmnopqrst"), 10, 9, SV("12345"), S("abcdefghij12345t"));
+ test(S("abcdefghijklmnopqrst"), 10, 9, SV("1234567890"), S("abcdefghij1234567890t"));
+ test(S("abcdefghijklmnopqrst"), 10, 9, SV("12345678901234567890"), S("abcdefghij12345678901234567890t"));
+ test(S("abcdefghijklmnopqrst"), 10, 10, SV(""), S("abcdefghij"));
+ test(S("abcdefghijklmnopqrst"), 10, 10, SV("12345"), S("abcdefghij12345"));
+ test(S("abcdefghijklmnopqrst"), 10, 10, SV("1234567890"), S("abcdefghij1234567890"));
+ test(S("abcdefghijklmnopqrst"), 10, 10, SV("12345678901234567890"), S("abcdefghij12345678901234567890"));
+ test(S("abcdefghijklmnopqrst"), 10, 11, SV(""), S("abcdefghij"));
+ test(S("abcdefghijklmnopqrst"), 10, 11, SV("12345"), S("abcdefghij12345"));
+ test(S("abcdefghijklmnopqrst"), 10, 11, SV("1234567890"), S("abcdefghij1234567890"));
+ test(S("abcdefghijklmnopqrst"), 10, 11, SV("12345678901234567890"), S("abcdefghij12345678901234567890"));
+ test(S("abcdefghijklmnopqrst"), 19, 0, SV(""), S("abcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 19, 0, SV("12345"), S("abcdefghijklmnopqrs12345t"));
+ test(S("abcdefghijklmnopqrst"), 19, 0, SV("1234567890"), S("abcdefghijklmnopqrs1234567890t"));
+ test(S("abcdefghijklmnopqrst"), 19, 0, SV("12345678901234567890"), S("abcdefghijklmnopqrs12345678901234567890t"));
+ test(S("abcdefghijklmnopqrst"), 19, 1, SV(""), S("abcdefghijklmnopqrs"));
+ test(S("abcdefghijklmnopqrst"), 19, 1, SV("12345"), S("abcdefghijklmnopqrs12345"));
+ test(S("abcdefghijklmnopqrst"), 19, 1, SV("1234567890"), S("abcdefghijklmnopqrs1234567890"));
+ test(S("abcdefghijklmnopqrst"), 19, 1, SV("12345678901234567890"), S("abcdefghijklmnopqrs12345678901234567890"));
+ test(S("abcdefghijklmnopqrst"), 19, 2, SV(""), S("abcdefghijklmnopqrs"));
+ test(S("abcdefghijklmnopqrst"), 19, 2, SV("12345"), S("abcdefghijklmnopqrs12345"));
+ test(S("abcdefghijklmnopqrst"), 19, 2, SV("1234567890"), S("abcdefghijklmnopqrs1234567890"));
+ test(S("abcdefghijklmnopqrst"), 19, 2, SV("12345678901234567890"), S("abcdefghijklmnopqrs12345678901234567890"));
+ test(S("abcdefghijklmnopqrst"), 20, 0, SV(""), S("abcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 20, 0, SV("12345"), S("abcdefghijklmnopqrst12345"));
+ test(S("abcdefghijklmnopqrst"), 20, 0, SV("1234567890"), S("abcdefghijklmnopqrst1234567890"));
+ test(S("abcdefghijklmnopqrst"), 20, 0, SV("12345678901234567890"), S("abcdefghijklmnopqrst12345678901234567890"));
+ test(S("abcdefghijklmnopqrst"), 20, 1, SV(""), S("abcdefghijklmnopqrst"));
+ test(S("abcdefghijklmnopqrst"), 20, 1, SV("12345"), S("abcdefghijklmnopqrst12345"));
+ test(S("abcdefghijklmnopqrst"), 20, 1, SV("1234567890"), S("abcdefghijklmnopqrst1234567890"));
+ test(S("abcdefghijklmnopqrst"), 20, 1, SV("12345678901234567890"), S("abcdefghijklmnopqrst12345678901234567890"));
+ test(S("abcdefghijklmnopqrst"), 21, 0, SV(""), S("can't happen"));
+ test(S("abcdefghijklmnopqrst"), 21, 0, SV("12345"), S("can't happen"));
+ test(S("abcdefghijklmnopqrst"), 21, 0, SV("1234567890"), S("can't happen"));
+ test(S("abcdefghijklmnopqrst"), 21, 0, SV("12345678901234567890"), S("can't happen"));
+}
+
+int main()
+{
+ {
+ typedef std::string S;
+ typedef std::string_view SV;
+ test0<S, SV>();
+ test1<S, SV>();
+ test2<S, SV>();
+ }
+#if TEST_STD_VER >= 11
+ {
+ typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+ typedef std::string_view SV;
+ test0<S, SV>();
+ test1<S, SV>();
+ test2<S, SV>();
+ }
+#endif
+}
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 88c1bee..7372719 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
@@ -68,7 +68,7 @@
{
typedef std::basic_string<char, std::char_traits<char>, some_alloc<char>> C;
#if TEST_STD_VER >= 14
- // In c++14, if POCS is set, swapping the allocator is required not to throw
+ // In C++14, if POCS is set, swapping the allocator is required not to throw
static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
#else
static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
diff --git a/test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp b/test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp
new file mode 100644
index 0000000..6a5ba22
--- /dev/null
+++ b/test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp
@@ -0,0 +1,383 @@
+//===----------------------------------------------------------------------===//
+//
+// The 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>
+
+// int compare(size_type pos1, size_type n1, basic_string_vew sv) const;
+
+#include <string>
+#include <stdexcept>
+#include <cassert>
+
+#include "min_allocator.h"
+
+#include "test_macros.h"
+
+int sign(int x)
+{
+ if (x == 0)
+ return 0;
+ if (x < 0)
+ return -1;
+ return 1;
+}
+
+template <class S, class SV>
+void
+test(const S& s, typename S::size_type pos1, typename S::size_type n1,
+ SV sv, int x)
+{
+ if (pos1 <= s.size())
+ assert(sign(s.compare(pos1, n1, sv)) == sign(x));
+#ifndef TEST_HAS_NO_EXCEPTIONS
+ else
+ {
+ try
+ {
+ s.compare(pos1, n1, sv);
+ assert(false);
+ }
+ catch (std::out_of_range&)
+ {
+ assert(pos1 > s.size());
+ }
+ }
+#endif
+}
+
+template <class S, class SV>
+void test0()
+{
+ test(S(""), 0, 0, SV(""), 0);
+ test(S(""), 0, 0, SV("abcde"), -5);
+ test(S(""), 0, 0, SV("abcdefghij"), -10);
+ test(S(""), 0, 0, SV("abcdefghijklmnopqrst"), -20);
+ test(S(""), 0, 1, SV(""), 0);
+ test(S(""), 0, 1, SV("abcde"), -5);
+ test(S(""), 0, 1, SV("abcdefghij"), -10);
+ test(S(""), 0, 1, SV("abcdefghijklmnopqrst"), -20);
+ test(S(""), 1, 0, SV(""), 0);
+ test(S(""), 1, 0, SV("abcde"), 0);
+ test(S(""), 1, 0, SV("abcdefghij"), 0);
+ test(S(""), 1, 0, SV("abcdefghijklmnopqrst"), 0);
+ test(S("abcde"), 0, 0, SV(""), 0);
+ test(S("abcde"), 0, 0, SV("abcde"), -5);
+ test(S("abcde"), 0, 0, SV("abcdefghij"), -10);
+ test(S("abcde"), 0, 0, SV("abcdefghijklmnopqrst"), -20);
+ test(S("abcde"), 0, 1, SV(""), 1);
+ test(S("abcde"), 0, 1, SV("abcde"), -4);
+ test(S("abcde"), 0, 1, SV("abcdefghij"), -9);
+ test(S("abcde"), 0, 1, SV("abcdefghijklmnopqrst"), -19);
+ test(S("abcde"), 0, 2, SV(""), 2);
+ test(S("abcde"), 0, 2, SV("abcde"), -3);
+ test(S("abcde"), 0, 2, SV("abcdefghij"), -8);
+ test(S("abcde"), 0, 2, SV("abcdefghijklmnopqrst"), -18);
+ test(S("abcde"), 0, 4, SV(""), 4);
+ test(S("abcde"), 0, 4, SV("abcde"), -1);
+ test(S("abcde"), 0, 4, SV("abcdefghij"), -6);
+ test(S("abcde"), 0, 4, SV("abcdefghijklmnopqrst"), -16);
+ test(S("abcde"), 0, 5, SV(""), 5);
+ test(S("abcde"), 0, 5, SV("abcde"), 0);
+ test(S("abcde"), 0, 5, SV("abcdefghij"), -5);
+ test(S("abcde"), 0, 5, SV("abcdefghijklmnopqrst"), -15);
+ test(S("abcde"), 0, 6, SV(""), 5);
+ test(S("abcde"), 0, 6, SV("abcde"), 0);
+ test(S("abcde"), 0, 6, SV("abcdefghij"), -5);
+ test(S("abcde"), 0, 6, SV("abcdefghijklmnopqrst"), -15);
+ test(S("abcde"), 1, 0, SV(""), 0);
+ test(S("abcde"), 1, 0, SV("abcde"), -5);
+ test(S("abcde"), 1, 0, SV("abcdefghij"), -10);
+ test(S("abcde"), 1, 0, SV("abcdefghijklmnopqrst"), -20);
+ test(S("abcde"), 1, 1, SV(""), 1);
+ test(S("abcde"), 1, 1, SV("abcde"), 1);
+ test(S("abcde"), 1, 1, SV("abcdefghij"), 1);
+ test(S("abcde"), 1, 1, SV("abcdefghijklmnopqrst"), 1);
+ test(S("abcde"), 1, 2, SV(""), 2);
+ test(S("abcde"), 1, 2, SV("abcde"), 1);
+ test(S("abcde"), 1, 2, SV("abcdefghij"), 1);
+ test(S("abcde"), 1, 2, SV("abcdefghijklmnopqrst"), 1);
+ test(S("abcde"), 1, 3, SV(""), 3);
+ test(S("abcde"), 1, 3, SV("abcde"), 1);
+ test(S("abcde"), 1, 3, SV("abcdefghij"), 1);
+ test(S("abcde"), 1, 3, SV("abcdefghijklmnopqrst"), 1);
+ test(S("abcde"), 1, 4, SV(""), 4);
+ test(S("abcde"), 1, 4, SV("abcde"), 1);
+ test(S("abcde"), 1, 4, SV("abcdefghij"), 1);
+ test(S("abcde"), 1, 4, SV("abcdefghijklmnopqrst"), 1);
+ test(S("abcde"), 1, 5, SV(""), 4);
+ test(S("abcde"), 1, 5, SV("abcde"), 1);
+ test(S("abcde"), 1, 5, SV("abcdefghij"), 1);
+ test(S("abcde"), 1, 5, SV("abcdefghijklmnopqrst"), 1);
+ test(S("abcde"), 2, 0, SV(""), 0);
+ test(S("abcde"), 2, 0, SV("abcde"), -5);
+ test(S("abcde"), 2, 0, SV("abcdefghij"), -10);
+ test(S("abcde"), 2, 0, SV("abcdefghijklmnopqrst"), -20);
+ test(S("abcde"), 2, 1, SV(""), 1);
+ test(S("abcde"), 2, 1, SV("abcde"), 2);
+ test(S("abcde"), 2, 1, SV("abcdefghij"), 2);
+ test(S("abcde"), 2, 1, SV("abcdefghijklmnopqrst"), 2);
+ test(S("abcde"), 2, 2, SV(""), 2);
+ test(S("abcde"), 2, 2, SV("abcde"), 2);
+ test(S("abcde"), 2, 2, SV("abcdefghij"), 2);
+ test(S("abcde"), 2, 2, SV("abcdefghijklmnopqrst"), 2);
+ test(S("abcde"), 2, 3, SV(""), 3);
+ test(S("abcde"), 2, 3, SV("abcde"), 2);
+ test(S("abcde"), 2, 3, SV("abcdefghij"), 2);
+ test(S("abcde"), 2, 3, SV("abcdefghijklmnopqrst"), 2);
+ test(S("abcde"), 2, 4, SV(""), 3);
+ test(S("abcde"), 2, 4, SV("abcde"), 2);
+ test(S("abcde"), 2, 4, SV("abcdefghij"), 2);
+ test(S("abcde"), 2, 4, SV("abcdefghijklmnopqrst"), 2);
+ test(S("abcde"), 4, 0, SV(""), 0);
+ test(S("abcde"), 4, 0, SV("abcde"), -5);
+ test(S("abcde"), 4, 0, SV("abcdefghij"), -10);
+ test(S("abcde"), 4, 0, SV("abcdefghijklmnopqrst"), -20);
+ test(S("abcde"), 4, 1, SV(""), 1);
+ test(S("abcde"), 4, 1, SV("abcde"), 4);
+ test(S("abcde"), 4, 1, SV("abcdefghij"), 4);
+ test(S("abcde"), 4, 1, SV("abcdefghijklmnopqrst"), 4);
+ test(S("abcde"), 4, 2, SV(""), 1);
+ test(S("abcde"), 4, 2, SV("abcde"), 4);
+ test(S("abcde"), 4, 2, SV("abcdefghij"), 4);
+ test(S("abcde"), 4, 2, SV("abcdefghijklmnopqrst"), 4);
+ test(S("abcde"), 5, 0, SV(""), 0);
+ test(S("abcde"), 5, 0, SV("abcde"), -5);
+ test(S("abcde"), 5, 0, SV("abcdefghij"), -10);
+ test(S("abcde"), 5, 0, SV("abcdefghijklmnopqrst"), -20);
+ test(S("abcde"), 5, 1, SV(""), 0);
+ test(S("abcde"), 5, 1, SV("abcde"), -5);
+ test(S("abcde"), 5, 1, SV("abcdefghij"), -10);
+ test(S("abcde"), 5, 1, SV("abcdefghijklmnopqrst"), -20);
+}
+
+template <class S, class SV>
+void test1()
+{
+ test(S("abcde"), 6, 0, SV(""), 0);
+ test(S("abcde"), 6, 0, SV("abcde"), 0);
+ test(S("abcde"), 6, 0, SV("abcdefghij"), 0);
+ test(S("abcde"), 6, 0, SV("abcdefghijklmnopqrst"), 0);
+ test(S("abcdefghij"), 0, 0, SV(""), 0);
+ test(S("abcdefghij"), 0, 0, SV("abcde"), -5);
+ test(S("abcdefghij"), 0, 0, SV("abcdefghij"), -10);
+ test(S("abcdefghij"), 0, 0, SV("abcdefghijklmnopqrst"), -20);
+ test(S("abcdefghij"), 0, 1, SV(""), 1);
+ test(S("abcdefghij"), 0, 1, SV("abcde"), -4);
+ test(S("abcdefghij"), 0, 1, SV("abcdefghij"), -9);
+ test(S("abcdefghij"), 0, 1, SV("abcdefghijklmnopqrst"), -19);
+ test(S("abcdefghij"), 0, 5, SV(""), 5);
+ test(S("abcdefghij"), 0, 5, SV("abcde"), 0);
+ test(S("abcdefghij"), 0, 5, SV("abcdefghij"), -5);
+ test(S("abcdefghij"), 0, 5, SV("abcdefghijklmnopqrst"), -15);
+ test(S("abcdefghij"), 0, 9, SV(""), 9);
+ test(S("abcdefghij"), 0, 9, SV("abcde"), 4);
+ test(S("abcdefghij"), 0, 9, SV("abcdefghij"), -1);
+ test(S("abcdefghij"), 0, 9, SV("abcdefghijklmnopqrst"), -11);
+ test(S("abcdefghij"), 0, 10, SV(""), 10);
+ test(S("abcdefghij"), 0, 10, SV("abcde"), 5);
+ test(S("abcdefghij"), 0, 10, SV("abcdefghij"), 0);
+ test(S("abcdefghij"), 0, 10, SV("abcdefghijklmnopqrst"), -10);
+ test(S("abcdefghij"), 0, 11, SV(""), 10);
+ test(S("abcdefghij"), 0, 11, SV("abcde"), 5);
+ test(S("abcdefghij"), 0, 11, SV("abcdefghij"), 0);
+ test(S("abcdefghij"), 0, 11, SV("abcdefghijklmnopqrst"), -10);
+ test(S("abcdefghij"), 1, 0, SV(""), 0);
+ test(S("abcdefghij"), 1, 0, SV("abcde"), -5);
+ test(S("abcdefghij"), 1, 0, SV("abcdefghij"), -10);
+ test(S("abcdefghij"), 1, 0, SV("abcdefghijklmnopqrst"), -20);
+ test(S("abcdefghij"), 1, 1, SV(""), 1);
+ test(S("abcdefghij"), 1, 1, SV("abcde"), 1);
+ test(S("abcdefghij"), 1, 1, SV("abcdefghij"), 1);
+ test(S("abcdefghij"), 1, 1, SV("abcdefghijklmnopqrst"), 1);
+ test(S("abcdefghij"), 1, 4, SV(""), 4);
+ test(S("abcdefghij"), 1, 4, SV("abcde"), 1);
+ test(S("abcdefghij"), 1, 4, SV("abcdefghij"), 1);
+ test(S("abcdefghij"), 1, 4, SV("abcdefghijklmnopqrst"), 1);
+ test(S("abcdefghij"), 1, 8, SV(""), 8);
+ test(S("abcdefghij"), 1, 8, SV("abcde"), 1);
+ test(S("abcdefghij"), 1, 8, SV("abcdefghij"), 1);
+ test(S("abcdefghij"), 1, 8, SV("abcdefghijklmnopqrst"), 1);
+ test(S("abcdefghij"), 1, 9, SV(""), 9);
+ test(S("abcdefghij"), 1, 9, SV("abcde"), 1);
+ test(S("abcdefghij"), 1, 9, SV("abcdefghij"), 1);
+ test(S("abcdefghij"), 1, 9, SV("abcdefghijklmnopqrst"), 1);
+ test(S("abcdefghij"), 1, 10, SV(""), 9);
+ test(S("abcdefghij"), 1, 10, SV("abcde"), 1);
+ test(S("abcdefghij"), 1, 10, SV("abcdefghij"), 1);
+ test(S("abcdefghij"), 1, 10, SV("abcdefghijklmnopqrst"), 1);
+ test(S("abcdefghij"), 5, 0, SV(""), 0);
+ test(S("abcdefghij"), 5, 0, SV("abcde"), -5);
+ test(S("abcdefghij"), 5, 0, SV("abcdefghij"), -10);
+ test(S("abcdefghij"), 5, 0, SV("abcdefghijklmnopqrst"), -20);
+ test(S("abcdefghij"), 5, 1, SV(""), 1);
+ test(S("abcdefghij"), 5, 1, SV("abcde"), 5);
+ test(S("abcdefghij"), 5, 1, SV("abcdefghij"), 5);
+ test(S("abcdefghij"), 5, 1, SV("abcdefghijklmnopqrst"), 5);
+ test(S("abcdefghij"), 5, 2, SV(""), 2);
+ test(S("abcdefghij"), 5, 2, SV("abcde"), 5);
+ test(S("abcdefghij"), 5, 2, SV("abcdefghij"), 5);
+ test(S("abcdefghij"), 5, 2, SV("abcdefghijklmnopqrst"), 5);
+ test(S("abcdefghij"), 5, 4, SV(""), 4);
+ test(S("abcdefghij"), 5, 4, SV("abcde"), 5);
+ test(S("abcdefghij"), 5, 4, SV("abcdefghij"), 5);
+ test(S("abcdefghij"), 5, 4, SV("abcdefghijklmnopqrst"), 5);
+ test(S("abcdefghij"), 5, 5, SV(""), 5);
+ test(S("abcdefghij"), 5, 5, SV("abcde"), 5);
+ test(S("abcdefghij"), 5, 5, SV("abcdefghij"), 5);
+ test(S("abcdefghij"), 5, 5, SV("abcdefghijklmnopqrst"), 5);
+ test(S("abcdefghij"), 5, 6, SV(""), 5);
+ test(S("abcdefghij"), 5, 6, SV("abcde"), 5);
+ test(S("abcdefghij"), 5, 6, SV("abcdefghij"), 5);
+ test(S("abcdefghij"), 5, 6, SV("abcdefghijklmnopqrst"), 5);
+ test(S("abcdefghij"), 9, 0, SV(""), 0);
+ test(S("abcdefghij"), 9, 0, SV("abcde"), -5);
+ test(S("abcdefghij"), 9, 0, SV("abcdefghij"), -10);
+ test(S("abcdefghij"), 9, 0, SV("abcdefghijklmnopqrst"), -20);
+ test(S("abcdefghij"), 9, 1, SV(""), 1);
+ test(S("abcdefghij"), 9, 1, SV("abcde"), 9);
+ test(S("abcdefghij"), 9, 1, SV("abcdefghij"), 9);
+ test(S("abcdefghij"), 9, 1, SV("abcdefghijklmnopqrst"), 9);
+ test(S("abcdefghij"), 9, 2, SV(""), 1);
+ test(S("abcdefghij"), 9, 2, SV("abcde"), 9);
+ test(S("abcdefghij"), 9, 2, SV("abcdefghij"), 9);
+ test(S("abcdefghij"), 9, 2, SV("abcdefghijklmnopqrst"), 9);
+ test(S("abcdefghij"), 10, 0, SV(""), 0);
+ test(S("abcdefghij"), 10, 0, SV("abcde"), -5);
+ test(S("abcdefghij"), 10, 0, SV("abcdefghij"), -10);
+ test(S("abcdefghij"), 10, 0, SV("abcdefghijklmnopqrst"), -20);
+ test(S("abcdefghij"), 10, 1, SV(""), 0);
+ test(S("abcdefghij"), 10, 1, SV("abcde"), -5);
+ test(S("abcdefghij"), 10, 1, SV("abcdefghij"), -10);
+ test(S("abcdefghij"), 10, 1, SV("abcdefghijklmnopqrst"), -20);
+ test(S("abcdefghij"), 11, 0, SV(""), 0);
+ test(S("abcdefghij"), 11, 0, SV("abcde"), 0);
+ test(S("abcdefghij"), 11, 0, SV("abcdefghij"), 0);
+ test(S("abcdefghij"), 11, 0, SV("abcdefghijklmnopqrst"), 0);
+}
+
+template <class S, class SV>
+void test2()
+{
+ test(S("abcdefghijklmnopqrst"), 0, 0, SV(""), 0);
+ test(S("abcdefghijklmnopqrst"), 0, 0, SV("abcde"), -5);
+ test(S("abcdefghijklmnopqrst"), 0, 0, SV("abcdefghij"), -10);
+ test(S("abcdefghijklmnopqrst"), 0, 0, SV("abcdefghijklmnopqrst"), -20);
+ test(S("abcdefghijklmnopqrst"), 0, 1, SV(""), 1);
+ test(S("abcdefghijklmnopqrst"), 0, 1, SV("abcde"), -4);
+ test(S("abcdefghijklmnopqrst"), 0, 1, SV("abcdefghij"), -9);
+ test(S("abcdefghijklmnopqrst"), 0, 1, SV("abcdefghijklmnopqrst"), -19);
+ test(S("abcdefghijklmnopqrst"), 0, 10, SV(""), 10);
+ test(S("abcdefghijklmnopqrst"), 0, 10, SV("abcde"), 5);
+ test(S("abcdefghijklmnopqrst"), 0, 10, SV("abcdefghij"), 0);
+ test(S("abcdefghijklmnopqrst"), 0, 10, SV("abcdefghijklmnopqrst"), -10);
+ test(S("abcdefghijklmnopqrst"), 0, 19, SV(""), 19);
+ test(S("abcdefghijklmnopqrst"), 0, 19, SV("abcde"), 14);
+ test(S("abcdefghijklmnopqrst"), 0, 19, SV("abcdefghij"), 9);
+ test(S("abcdefghijklmnopqrst"), 0, 19, SV("abcdefghijklmnopqrst"), -1);
+ test(S("abcdefghijklmnopqrst"), 0, 20, SV(""), 20);
+ test(S("abcdefghijklmnopqrst"), 0, 20, SV("abcde"), 15);
+ test(S("abcdefghijklmnopqrst"), 0, 20, SV("abcdefghij"), 10);
+ test(S("abcdefghijklmnopqrst"), 0, 20, SV("abcdefghijklmnopqrst"), 0);
+ test(S("abcdefghijklmnopqrst"), 0, 21, SV(""), 20);
+ test(S("abcdefghijklmnopqrst"), 0, 21, SV("abcde"), 15);
+ test(S("abcdefghijklmnopqrst"), 0, 21, SV("abcdefghij"), 10);
+ test(S("abcdefghijklmnopqrst"), 0, 21, SV("abcdefghijklmnopqrst"), 0);
+ test(S("abcdefghijklmnopqrst"), 1, 0, SV(""), 0);
+ test(S("abcdefghijklmnopqrst"), 1, 0, SV("abcde"), -5);
+ test(S("abcdefghijklmnopqrst"), 1, 0, SV("abcdefghij"), -10);
+ test(S("abcdefghijklmnopqrst"), 1, 0, SV("abcdefghijklmnopqrst"), -20);
+ test(S("abcdefghijklmnopqrst"), 1, 1, SV(""), 1);
+ test(S("abcdefghijklmnopqrst"), 1, 1, SV("abcde"), 1);
+ test(S("abcdefghijklmnopqrst"), 1, 1, SV("abcdefghij"), 1);
+ test(S("abcdefghijklmnopqrst"), 1, 1, SV("abcdefghijklmnopqrst"), 1);
+ test(S("abcdefghijklmnopqrst"), 1, 9, SV(""), 9);
+ test(S("abcdefghijklmnopqrst"), 1, 9, SV("abcde"), 1);
+ test(S("abcdefghijklmnopqrst"), 1, 9, SV("abcdefghij"), 1);
+ test(S("abcdefghijklmnopqrst"), 1, 9, SV("abcdefghijklmnopqrst"), 1);
+ test(S("abcdefghijklmnopqrst"), 1, 18, SV(""), 18);
+ test(S("abcdefghijklmnopqrst"), 1, 18, SV("abcde"), 1);
+ test(S("abcdefghijklmnopqrst"), 1, 18, SV("abcdefghij"), 1);
+ test(S("abcdefghijklmnopqrst"), 1, 18, SV("abcdefghijklmnopqrst"), 1);
+ test(S("abcdefghijklmnopqrst"), 1, 19, SV(""), 19);
+ test(S("abcdefghijklmnopqrst"), 1, 19, SV("abcde"), 1);
+ test(S("abcdefghijklmnopqrst"), 1, 19, SV("abcdefghij"), 1);
+ test(S("abcdefghijklmnopqrst"), 1, 19, SV("abcdefghijklmnopqrst"), 1);
+ test(S("abcdefghijklmnopqrst"), 1, 20, SV(""), 19);
+ test(S("abcdefghijklmnopqrst"), 1, 20, SV("abcde"), 1);
+ test(S("abcdefghijklmnopqrst"), 1, 20, SV("abcdefghij"), 1);
+ test(S("abcdefghijklmnopqrst"), 1, 20, SV("abcdefghijklmnopqrst"), 1);
+ test(S("abcdefghijklmnopqrst"), 10, 0, SV(""), 0);
+ test(S("abcdefghijklmnopqrst"), 10, 0, SV("abcde"), -5);
+ test(S("abcdefghijklmnopqrst"), 10, 0, SV("abcdefghij"), -10);
+ test(S("abcdefghijklmnopqrst"), 10, 0, SV("abcdefghijklmnopqrst"), -20);
+ test(S("abcdefghijklmnopqrst"), 10, 1, SV(""), 1);
+ test(S("abcdefghijklmnopqrst"), 10, 1, SV("abcde"), 10);
+ test(S("abcdefghijklmnopqrst"), 10, 1, SV("abcdefghij"), 10);
+ test(S("abcdefghijklmnopqrst"), 10, 1, SV("abcdefghijklmnopqrst"), 10);
+ test(S("abcdefghijklmnopqrst"), 10, 5, SV(""), 5);
+ test(S("abcdefghijklmnopqrst"), 10, 5, SV("abcde"), 10);
+ test(S("abcdefghijklmnopqrst"), 10, 5, SV("abcdefghij"), 10);
+ test(S("abcdefghijklmnopqrst"), 10, 5, SV("abcdefghijklmnopqrst"), 10);
+ test(S("abcdefghijklmnopqrst"), 10, 9, SV(""), 9);
+ test(S("abcdefghijklmnopqrst"), 10, 9, SV("abcde"), 10);
+ test(S("abcdefghijklmnopqrst"), 10, 9, SV("abcdefghij"), 10);
+ test(S("abcdefghijklmnopqrst"), 10, 9, SV("abcdefghijklmnopqrst"), 10);
+ test(S("abcdefghijklmnopqrst"), 10, 10, SV(""), 10);
+ test(S("abcdefghijklmnopqrst"), 10, 10, SV("abcde"), 10);
+ test(S("abcdefghijklmnopqrst"), 10, 10, SV("abcdefghij"), 10);
+ test(S("abcdefghijklmnopqrst"), 10, 10, SV("abcdefghijklmnopqrst"), 10);
+ test(S("abcdefghijklmnopqrst"), 10, 11, SV(""), 10);
+ test(S("abcdefghijklmnopqrst"), 10, 11, SV("abcde"), 10);
+ test(S("abcdefghijklmnopqrst"), 10, 11, SV("abcdefghij"), 10);
+ test(S("abcdefghijklmnopqrst"), 10, 11, SV("abcdefghijklmnopqrst"), 10);
+ test(S("abcdefghijklmnopqrst"), 19, 0, SV(""), 0);
+ test(S("abcdefghijklmnopqrst"), 19, 0, SV("abcde"), -5);
+ test(S("abcdefghijklmnopqrst"), 19, 0, SV("abcdefghij"), -10);
+ test(S("abcdefghijklmnopqrst"), 19, 0, SV("abcdefghijklmnopqrst"), -20);
+ test(S("abcdefghijklmnopqrst"), 19, 1, SV(""), 1);
+ test(S("abcdefghijklmnopqrst"), 19, 1, SV("abcde"), 19);
+ test(S("abcdefghijklmnopqrst"), 19, 1, SV("abcdefghij"), 19);
+ test(S("abcdefghijklmnopqrst"), 19, 1, SV("abcdefghijklmnopqrst"), 19);
+ test(S("abcdefghijklmnopqrst"), 19, 2, SV(""), 1);
+ test(S("abcdefghijklmnopqrst"), 19, 2, SV("abcde"), 19);
+ test(S("abcdefghijklmnopqrst"), 19, 2, SV("abcdefghij"), 19);
+ test(S("abcdefghijklmnopqrst"), 19, 2, SV("abcdefghijklmnopqrst"), 19);
+ test(S("abcdefghijklmnopqrst"), 20, 0, SV(""), 0);
+ test(S("abcdefghijklmnopqrst"), 20, 0, SV("abcde"), -5);
+ test(S("abcdefghijklmnopqrst"), 20, 0, SV("abcdefghij"), -10);
+ test(S("abcdefghijklmnopqrst"), 20, 0, SV("abcdefghijklmnopqrst"), -20);
+ test(S("abcdefghijklmnopqrst"), 20, 1, SV(""), 0);
+ test(S("abcdefghijklmnopqrst"), 20, 1, SV("abcde"), -5);
+ test(S("abcdefghijklmnopqrst"), 20, 1, SV("abcdefghij"), -10);
+ test(S("abcdefghijklmnopqrst"), 20, 1, SV("abcdefghijklmnopqrst"), -20);
+ test(S("abcdefghijklmnopqrst"), 21, 0, SV(""), 0);
+ test(S("abcdefghijklmnopqrst"), 21, 0, SV("abcde"), 0);
+ test(S("abcdefghijklmnopqrst"), 21, 0, SV("abcdefghij"), 0);
+ test(S("abcdefghijklmnopqrst"), 21, 0, SV("abcdefghijklmnopqrst"), 0);
+}
+
+int main()
+{
+ {
+ typedef std::string S;
+ typedef std::string_view SV;
+ test0<S, SV>();
+ test1<S, SV>();
+ test2<S, SV>();
+ }
+#if TEST_STD_VER >= 11
+ {
+ typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+ typedef std::string_view SV;
+ test0<S, SV>();
+ test1<S, SV>();
+ test2<S, SV>();
+ }
+#endif
+}
diff --git a/test/std/strings/basic.string/string.ops/string_compare/string_view.pass.cpp b/test/std/strings/basic.string/string.ops/string_compare/string_view.pass.cpp
new file mode 100644
index 0000000..8f0d488
--- /dev/null
+++ b/test/std/strings/basic.string/string.ops/string_compare/string_view.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <string>
+
+// int compare(const basic_string_view sv) const
+
+#include <string>
+#include <cassert>
+
+#include "min_allocator.h"
+
+int sign(int x)
+{
+ if (x == 0)
+ return 0;
+ if (x < 0)
+ return -1;
+ return 1;
+}
+
+template <class S, class SV>
+void
+test(const S& s, SV sv, int x)
+{
+ assert(sign(s.compare(sv)) == sign(x));
+}
+
+int main()
+{
+ {
+ typedef std::string S;
+ typedef std::string_view SV;
+ test(S(""), SV(""), 0);
+ test(S(""), SV("abcde"), -5);
+ test(S(""), SV("abcdefghij"), -10);
+ test(S(""), SV("abcdefghijklmnopqrst"), -20);
+ test(S("abcde"), SV(""), 5);
+ test(S("abcde"), SV("abcde"), 0);
+ test(S("abcde"), SV("abcdefghij"), -5);
+ test(S("abcde"), SV("abcdefghijklmnopqrst"), -15);
+ test(S("abcdefghij"), SV(""), 10);
+ test(S("abcdefghij"), SV("abcde"), 5);
+ test(S("abcdefghij"), SV("abcdefghij"), 0);
+ test(S("abcdefghij"), SV("abcdefghijklmnopqrst"), -10);
+ test(S("abcdefghijklmnopqrst"), SV(""), 20);
+ test(S("abcdefghijklmnopqrst"), SV("abcde"), 15);
+ test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), 10);
+ test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), 0);
+ }
+#if TEST_STD_VER >= 11
+ {
+ typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+ typedef std::string_view SV;
+ test(S(""), SV(""), 0);
+ test(S(""), SV("abcde"), -5);
+ test(S(""), SV("abcdefghij"), -10);
+ test(S(""), SV("abcdefghijklmnopqrst"), -20);
+ test(S("abcde"), SV(""), 5);
+ test(S("abcde"), SV("abcde"), 0);
+ test(S("abcde"), SV("abcdefghij"), -5);
+ test(S("abcde"), SV("abcdefghijklmnopqrst"), -15);
+ test(S("abcdefghij"), SV(""), 10);
+ test(S("abcdefghij"), SV("abcde"), 5);
+ test(S("abcdefghij"), SV("abcdefghij"), 0);
+ test(S("abcdefghij"), SV("abcdefghijklmnopqrst"), -10);
+ test(S("abcdefghijklmnopqrst"), SV(""), 20);
+ test(S("abcdefghijklmnopqrst"), SV("abcde"), 15);
+ test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), 10);
+ test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), 0);
+ }
+#endif
+}
diff --git a/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_view_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_view_size.pass.cpp
new file mode 100644
index 0000000..fb69f8b
--- /dev/null
+++ b/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_view_size.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <string>
+
+// size_type find_first_not_of(basic_string_view sv, size_type pos = 0) const;
+
+#include <string>
+#include <cassert>
+
+#include "min_allocator.h"
+
+template <class S, class SV>
+void
+test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
+{
+ assert(s.find_first_not_of(sv, pos) == x);
+ if (x != S::npos)
+ assert(pos <= x && x < s.size());
+}
+
+template <class S, class SV>
+void
+test(const S& s, SV sv, typename S::size_type x)
+{
+ assert(s.find_first_not_of(sv) == x);
+ if (x != S::npos)
+ assert(x < s.size());
+}
+
+template <class S, class SV>
+void test0()
+{
+ test(S(""), SV(""), 0, S::npos);
+ test(S(""), SV("laenf"), 0, S::npos);
+ test(S(""), SV("pqlnkmbdjo"), 0, S::npos);
+ test(S(""), SV("qkamfogpnljdcshbreti"), 0, S::npos);
+ test(S(""), SV(""), 1, S::npos);
+ test(S(""), SV("bjaht"), 1, S::npos);
+ test(S(""), SV("hjlcmgpket"), 1, S::npos);
+ test(S(""), SV("htaobedqikfplcgjsmrn"), 1, S::npos);
+ test(S("fodgq"), SV(""), 0, 0);
+ test(S("qanej"), SV("dfkap"), 0, 0);
+ test(S("clbao"), SV("ihqrfebgad"), 0, 0);
+ test(S("mekdn"), SV("ngtjfcalbseiqrphmkdo"), 0, S::npos);
+ test(S("srdfq"), SV(""), 1, 1);
+ test(S("oemth"), SV("ikcrq"), 1, 1);
+ test(S("cdaih"), SV("dmajblfhsg"), 1, 3);
+ test(S("qohtk"), SV("oqftjhdmkgsblacenirp"), 1, S::npos);
+ test(S("cshmd"), SV(""), 2, 2);
+ test(S("lhcdo"), SV("oebqi"), 2, 2);
+ test(S("qnsoh"), SV("kojhpmbsfe"), 2, S::npos);
+ test(S("pkrof"), SV("acbsjqogpltdkhinfrem"), 2, S::npos);
+ test(S("fmtsp"), SV(""), 4, 4);
+ test(S("khbpm"), SV("aobjd"), 4, 4);
+ test(S("pbsji"), SV("pcbahntsje"), 4, 4);
+ test(S("mprdj"), SV("fhepcrntkoagbmldqijs"), 4, S::npos);
+ test(S("eqmpa"), SV(""), 5, S::npos);
+ test(S("omigs"), SV("kocgb"), 5, S::npos);
+ test(S("onmje"), SV("fbslrjiqkm"), 5, S::npos);
+ test(S("oqmrj"), SV("jeidpcmalhfnqbgtrsko"), 5, S::npos);
+ test(S("schfa"), SV(""), 6, S::npos);
+ test(S("igdsc"), SV("qngpd"), 6, S::npos);
+ test(S("brqgo"), SV("rodhqklgmb"), 6, S::npos);
+ test(S("tnrph"), SV("thdjgafrlbkoiqcspmne"), 6, S::npos);
+ test(S("hcjitbfapl"), SV(""), 0, 0);
+ test(S("daiprenocl"), SV("ashjd"), 0, 2);
+ test(S("litpcfdghe"), SV("mgojkldsqh"), 0, 1);
+ test(S("aidjksrolc"), SV("imqnaghkfrdtlopbjesc"), 0, S::npos);
+ test(S("qpghtfbaji"), SV(""), 1, 1);
+ test(S("gfshlcmdjr"), SV("nadkh"), 1, 1);
+ test(S("nkodajteqp"), SV("ofdrqmkebl"), 1, 4);
+ test(S("gbmetiprqd"), SV("bdfjqgatlksriohemnpc"), 1, S::npos);
+ test(S("crnklpmegd"), SV(""), 5, 5);
+ test(S("jsbtafedoc"), SV("prqgn"), 5, 5);
+ test(S("qnmodrtkeb"), SV("pejafmnokr"), 5, 6);
+ test(S("cpebqsfmnj"), SV("odnqkgijrhabfmcestlp"), 5, S::npos);
+ test(S("lmofqdhpki"), SV(""), 9, 9);
+ test(S("hnefkqimca"), SV("rtjpa"), 9, S::npos);
+ test(S("drtasbgmfp"), SV("ktsrmnqagd"), 9, 9);
+ test(S("lsaijeqhtr"), SV("rtdhgcisbnmoaqkfpjle"), 9, S::npos);
+ test(S("elgofjmbrq"), SV(""), 10, S::npos);
+ test(S("mjqdgalkpc"), SV("dplqa"), 10, S::npos);
+ test(S("kthqnfcerm"), SV("dkacjoptns"), 10, S::npos);
+ test(S("dfsjhanorc"), SV("hqfimtrgnbekpdcsjalo"), 10, S::npos);
+ test(S("eqsgalomhb"), SV(""), 11, S::npos);
+ test(S("akiteljmoh"), SV("lofbc"), 11, S::npos);
+ test(S("hlbdfreqjo"), SV("astoegbfpn"), 11, S::npos);
+ test(S("taqobhlerg"), SV("pdgreqomsncafklhtibj"), 11, S::npos);
+ test(S("snafbdlghrjkpqtoceim"), SV(""), 0, 0);
+ test(S("aemtbrgcklhndjisfpoq"), SV("lbtqd"), 0, 0);
+ test(S("pnracgfkjdiholtbqsem"), SV("tboimldpjh"), 0, 1);
+ test(S("dicfltehbsgrmojnpkaq"), SV("slcerthdaiqjfnobgkpm"), 0, S::npos);
+ test(S("jlnkraeodhcspfgbqitm"), SV(""), 1, 1);
+ test(S("lhosrngtmfjikbqpcade"), SV("aqibs"), 1, 1);
+ test(S("rbtaqjhgkneisldpmfoc"), SV("gtfblmqinc"), 1, 3);
+ test(S("gpifsqlrdkbonjtmheca"), SV("mkqpbtdalgniorhfescj"), 1, S::npos);
+ test(S("hdpkobnsalmcfijregtq"), SV(""), 10, 10);
+ test(S("jtlshdgqaiprkbcoenfm"), SV("pblas"), 10, 11);
+ test(S("fkdrbqltsgmcoiphneaj"), SV("arosdhcfme"), 10, 13);
+ test(S("crsplifgtqedjohnabmk"), SV("blkhjeogicatqfnpdmsr"), 10, S::npos);
+ test(S("niptglfbosehkamrdqcj"), SV(""), 19, 19);
+ test(S("copqdhstbingamjfkler"), SV("djkqc"), 19, 19);
+ test(S("mrtaefilpdsgocnhqbjk"), SV("lgokshjtpb"), 19, S::npos);
+ test(S("kojatdhlcmigpbfrqnes"), SV("bqjhtkfepimcnsgrlado"), 19, S::npos);
+ test(S("eaintpchlqsbdgrkjofm"), SV(""), 20, S::npos);
+ test(S("gjnhidfsepkrtaqbmclo"), SV("nocfa"), 20, S::npos);
+ test(S("spocfaktqdbiejlhngmr"), SV("bgtajmiedc"), 20, S::npos);
+ test(S("rphmlekgfscndtaobiqj"), SV("lsckfnqgdahejiopbtmr"), 20, S::npos);
+ test(S("liatsqdoegkmfcnbhrpj"), SV(""), 21, S::npos);
+ test(S("binjagtfldkrspcomqeh"), SV("gfsrt"), 21, S::npos);
+ test(S("latkmisecnorjbfhqpdg"), SV("pfsocbhjtm"), 21, S::npos);
+ test(S("lecfratdjkhnsmqpoigb"), SV("tpflmdnoicjgkberhqsa"), 21, S::npos);
+}
+
+template <class S, class SV>
+void test1()
+{
+ test(S(""), SV(""), S::npos);
+ test(S(""), SV("laenf"), S::npos);
+ test(S(""), SV("pqlnkmbdjo"), S::npos);
+ test(S(""), SV("qkamfogpnljdcshbreti"), S::npos);
+ test(S("nhmko"), SV(""), 0);
+ test(S("lahfb"), SV("irkhs"), 0);
+ test(S("gmfhd"), SV("kantesmpgj"), 2);
+ test(S("odaft"), SV("oknlrstdpiqmjbaghcfe"), S::npos);
+ test(S("eolhfgpjqk"), SV(""), 0);
+ test(S("nbatdlmekr"), SV("bnrpe"), 2);
+ test(S("jdmciepkaq"), SV("jtdaefblso"), 2);
+ test(S("hkbgspoflt"), SV("oselktgbcapndfjihrmq"), S::npos);
+ test(S("gprdcokbnjhlsfmtieqa"), SV(""), 0);
+ test(S("qjghlnftcaismkropdeb"), SV("bjaht"), 0);
+ test(S("pnalfrdtkqcmojiesbhg"), SV("hjlcmgpket"), 1);
+ test(S("pniotcfrhqsmgdkjbael"), SV("htaobedqikfplcgjsmrn"), S::npos);
+}
+
+int main()
+{
+ {
+ typedef std::string S;
+ typedef std::string_view SV;
+ test0<S, SV>();
+ test1<S, SV>();
+ }
+#if TEST_STD_VER >= 11
+ {
+ typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+ typedef std::string_view SV;
+ test0<S, SV>();
+ test1<S, SV>();
+ }
+#endif
+}
diff --git a/test/std/strings/basic.string/string.ops/string_find.first.of/string_view_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.first.of/string_view_size.pass.cpp
new file mode 100644
index 0000000..05925af
--- /dev/null
+++ b/test/std/strings/basic.string/string.ops/string_find.first.of/string_view_size.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <string>
+
+// size_type find_first_of(const basic_string_view sv, size_type pos = 0) const;
+
+#include <string>
+#include <cassert>
+
+#include "min_allocator.h"
+
+template <class S, class SV>
+void
+test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
+{
+ assert(s.find_first_of(sv, pos) == x);
+ if (x != S::npos)
+ assert(pos <= x && x < s.size());
+}
+
+template <class S, class SV>
+void
+test(const S& s, SV sv, typename S::size_type x)
+{
+ assert(s.find_first_of(sv) == x);
+ if (x != S::npos)
+ assert(x < s.size());
+}
+
+template <class S, class SV>
+void test0()
+{
+ test(S(""), SV(""), 0, S::npos);
+ test(S(""), SV("laenf"), 0, S::npos);
+ test(S(""), SV("pqlnkmbdjo"), 0, S::npos);
+ test(S(""), SV("qkamfogpnljdcshbreti"), 0, S::npos);
+ test(S(""), SV(""), 1, S::npos);
+ test(S(""), SV("bjaht"), 1, S::npos);
+ test(S(""), SV("hjlcmgpket"), 1, S::npos);
+ test(S(""), SV("htaobedqikfplcgjsmrn"), 1, S::npos);
+ test(S("fodgq"), SV(""), 0, S::npos);
+ test(S("qanej"), SV("dfkap"), 0, 1);
+ test(S("clbao"), SV("ihqrfebgad"), 0, 2);
+ test(S("mekdn"), SV("ngtjfcalbseiqrphmkdo"), 0, 0);
+ test(S("srdfq"), SV(""), 1, S::npos);
+ test(S("oemth"), SV("ikcrq"), 1, S::npos);
+ test(S("cdaih"), SV("dmajblfhsg"), 1, 1);
+ test(S("qohtk"), SV("oqftjhdmkgsblacenirp"), 1, 1);
+ test(S("cshmd"), SV(""), 2, S::npos);
+ test(S("lhcdo"), SV("oebqi"), 2, 4);
+ test(S("qnsoh"), SV("kojhpmbsfe"), 2, 2);
+ test(S("pkrof"), SV("acbsjqogpltdkhinfrem"), 2, 2);
+ test(S("fmtsp"), SV(""), 4, S::npos);
+ test(S("khbpm"), SV("aobjd"), 4, S::npos);
+ test(S("pbsji"), SV("pcbahntsje"), 4, S::npos);
+ test(S("mprdj"), SV("fhepcrntkoagbmldqijs"), 4, 4);
+ test(S("eqmpa"), SV(""), 5, S::npos);
+ test(S("omigs"), SV("kocgb"), 5, S::npos);
+ test(S("onmje"), SV("fbslrjiqkm"), 5, S::npos);
+ test(S("oqmrj"), SV("jeidpcmalhfnqbgtrsko"), 5, S::npos);
+ test(S("schfa"), SV(""), 6, S::npos);
+ test(S("igdsc"), SV("qngpd"), 6, S::npos);
+ test(S("brqgo"), SV("rodhqklgmb"), 6, S::npos);
+ test(S("tnrph"), SV("thdjgafrlbkoiqcspmne"), 6, S::npos);
+ test(S("hcjitbfapl"), SV(""), 0, S::npos);
+ test(S("daiprenocl"), SV("ashjd"), 0, 0);
+ test(S("litpcfdghe"), SV("mgojkldsqh"), 0, 0);
+ test(S("aidjksrolc"), SV("imqnaghkfrdtlopbjesc"), 0, 0);
+ test(S("qpghtfbaji"), SV(""), 1, S::npos);
+ test(S("gfshlcmdjr"), SV("nadkh"), 1, 3);
+ test(S("nkodajteqp"), SV("ofdrqmkebl"), 1, 1);
+ test(S("gbmetiprqd"), SV("bdfjqgatlksriohemnpc"), 1, 1);
+ test(S("crnklpmegd"), SV(""), 5, S::npos);
+ test(S("jsbtafedoc"), SV("prqgn"), 5, S::npos);
+ test(S("qnmodrtkeb"), SV("pejafmnokr"), 5, 5);
+ test(S("cpebqsfmnj"), SV("odnqkgijrhabfmcestlp"), 5, 5);
+ test(S("lmofqdhpki"), SV(""), 9, S::npos);
+ test(S("hnefkqimca"), SV("rtjpa"), 9, 9);
+ test(S("drtasbgmfp"), SV("ktsrmnqagd"), 9, S::npos);
+ test(S("lsaijeqhtr"), SV("rtdhgcisbnmoaqkfpjle"), 9, 9);
+ test(S("elgofjmbrq"), SV(""), 10, S::npos);
+ test(S("mjqdgalkpc"), SV("dplqa"), 10, S::npos);
+ test(S("kthqnfcerm"), SV("dkacjoptns"), 10, S::npos);
+ test(S("dfsjhanorc"), SV("hqfimtrgnbekpdcsjalo"), 10, S::npos);
+ test(S("eqsgalomhb"), SV(""), 11, S::npos);
+ test(S("akiteljmoh"), SV("lofbc"), 11, S::npos);
+ test(S("hlbdfreqjo"), SV("astoegbfpn"), 11, S::npos);
+ test(S("taqobhlerg"), SV("pdgreqomsncafklhtibj"), 11, S::npos);
+ test(S("snafbdlghrjkpqtoceim"), SV(""), 0, S::npos);
+ test(S("aemtbrgcklhndjisfpoq"), SV("lbtqd"), 0, 3);
+ test(S("pnracgfkjdiholtbqsem"), SV("tboimldpjh"), 0, 0);
+ test(S("dicfltehbsgrmojnpkaq"), SV("slcerthdaiqjfnobgkpm"), 0, 0);
+ test(S("jlnkraeodhcspfgbqitm"), SV(""), 1, S::npos);
+ test(S("lhosrngtmfjikbqpcade"), SV("aqibs"), 1, 3);
+ test(S("rbtaqjhgkneisldpmfoc"), SV("gtfblmqinc"), 1, 1);
+ test(S("gpifsqlrdkbonjtmheca"), SV("mkqpbtdalgniorhfescj"), 1, 1);
+ test(S("hdpkobnsalmcfijregtq"), SV(""), 10, S::npos);
+ test(S("jtlshdgqaiprkbcoenfm"), SV("pblas"), 10, 10);
+ test(S("fkdrbqltsgmcoiphneaj"), SV("arosdhcfme"), 10, 10);
+ test(S("crsplifgtqedjohnabmk"), SV("blkhjeogicatqfnpdmsr"), 10, 10);
+ test(S("niptglfbosehkamrdqcj"), SV(""), 19, S::npos);
+ test(S("copqdhstbingamjfkler"), SV("djkqc"), 19, S::npos);
+ test(S("mrtaefilpdsgocnhqbjk"), SV("lgokshjtpb"), 19, 19);
+ test(S("kojatdhlcmigpbfrqnes"), SV("bqjhtkfepimcnsgrlado"), 19, 19);
+ test(S("eaintpchlqsbdgrkjofm"), SV(""), 20, S::npos);
+ test(S("gjnhidfsepkrtaqbmclo"), SV("nocfa"), 20, S::npos);
+ test(S("spocfaktqdbiejlhngmr"), SV("bgtajmiedc"), 20, S::npos);
+ test(S("rphmlekgfscndtaobiqj"), SV("lsckfnqgdahejiopbtmr"), 20, S::npos);
+ test(S("liatsqdoegkmfcnbhrpj"), SV(""), 21, S::npos);
+ test(S("binjagtfldkrspcomqeh"), SV("gfsrt"), 21, S::npos);
+ test(S("latkmisecnorjbfhqpdg"), SV("pfsocbhjtm"), 21, S::npos);
+ test(S("lecfratdjkhnsmqpoigb"), SV("tpflmdnoicjgkberhqsa"), 21, S::npos);
+}
+
+template <class S, class SV>
+void test1()
+{
+ test(S(""), SV(""), S::npos);
+ test(S(""), SV("laenf"), S::npos);
+ test(S(""), SV("pqlnkmbdjo"), S::npos);
+ test(S(""), SV("qkamfogpnljdcshbreti"), S::npos);
+ test(S("nhmko"), SV(""), S::npos);
+ test(S("lahfb"), SV("irkhs"), 2);
+ test(S("gmfhd"), SV("kantesmpgj"), 0);
+ test(S("odaft"), SV("oknlrstdpiqmjbaghcfe"), 0);
+ test(S("eolhfgpjqk"), SV(""), S::npos);
+ test(S("nbatdlmekr"), SV("bnrpe"), 0);
+ test(S("jdmciepkaq"), SV("jtdaefblso"), 0);
+ test(S("hkbgspoflt"), SV("oselktgbcapndfjihrmq"), 0);
+ test(S("gprdcokbnjhlsfmtieqa"), SV(""), S::npos);
+ test(S("qjghlnftcaismkropdeb"), SV("bjaht"), 1);
+ test(S("pnalfrdtkqcmojiesbhg"), SV("hjlcmgpket"), 0);
+ test(S("pniotcfrhqsmgdkjbael"), SV("htaobedqikfplcgjsmrn"), 0);
+}
+
+int main()
+{
+ {
+ typedef std::string S;
+ typedef std::string_view SV;
+ test0<S, SV>();
+ test1<S, SV>();
+ }
+#if TEST_STD_VER >= 11
+ {
+ typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+ typedef std::string_view SV;
+ test0<S, SV>();
+ test1<S, SV>();
+ }
+#endif
+}
diff --git a/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp
new file mode 100644
index 0000000..7e46ff7
--- /dev/null
+++ b/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <string>
+
+// size_type find_last_not_of(basic_string_view sv, size_type pos = npos) const;
+
+#include <string>
+#include <cassert>
+
+#include "min_allocator.h"
+
+template <class S, class SV>
+void
+test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
+{
+ assert(s.find_last_not_of(sv, pos) == x);
+ if (x != S::npos)
+ assert(x <= pos && x < s.size());
+}
+
+template <class S, class SV>
+void
+test(const S& s, SV sv, typename S::size_type x)
+{
+ assert(s.find_last_not_of(sv) == x);
+ if (x != S::npos)
+ assert(x < s.size());
+}
+
+template <class S, class SV>
+void test0()
+{
+ test(S(""), SV(""), 0, S::npos);
+ test(S(""), SV("laenf"), 0, S::npos);
+ test(S(""), SV("pqlnkmbdjo"), 0, S::npos);
+ test(S(""), SV("qkamfogpnljdcshbreti"), 0, S::npos);
+ test(S(""), SV(""), 1, S::npos);
+ test(S(""), SV("bjaht"), 1, S::npos);
+ test(S(""), SV("hjlcmgpket"), 1, S::npos);
+ test(S(""), SV("htaobedqikfplcgjsmrn"), 1, S::npos);
+ test(S("fodgq"), SV(""), 0, 0);
+ test(S("qanej"), SV("dfkap"), 0, 0);
+ test(S("clbao"), SV("ihqrfebgad"), 0, 0);
+ test(S("mekdn"), SV("ngtjfcalbseiqrphmkdo"), 0, S::npos);
+ test(S("srdfq"), SV(""), 1, 1);
+ test(S("oemth"), SV("ikcrq"), 1, 1);
+ test(S("cdaih"), SV("dmajblfhsg"), 1, 0);
+ test(S("qohtk"), SV("oqftjhdmkgsblacenirp"), 1, S::npos);
+ test(S("cshmd"), SV(""), 2, 2);
+ test(S("lhcdo"), SV("oebqi"), 2, 2);
+ test(S("qnsoh"), SV("kojhpmbsfe"), 2, 1);
+ test(S("pkrof"), SV("acbsjqogpltdkhinfrem"), 2, S::npos);
+ test(S("fmtsp"), SV(""), 4, 4);
+ test(S("khbpm"), SV("aobjd"), 4, 4);
+ test(S("pbsji"), SV("pcbahntsje"), 4, 4);
+ test(S("mprdj"), SV("fhepcrntkoagbmldqijs"), 4, S::npos);
+ test(S("eqmpa"), SV(""), 5, 4);
+ test(S("omigs"), SV("kocgb"), 5, 4);
+ test(S("onmje"), SV("fbslrjiqkm"), 5, 4);
+ test(S("oqmrj"), SV("jeidpcmalhfnqbgtrsko"), 5, S::npos);
+ test(S("schfa"), SV(""), 6, 4);
+ test(S("igdsc"), SV("qngpd"), 6, 4);
+ test(S("brqgo"), SV("rodhqklgmb"), 6, S::npos);
+ test(S("tnrph"), SV("thdjgafrlbkoiqcspmne"), 6, S::npos);
+ test(S("hcjitbfapl"), SV(""), 0, 0);
+ test(S("daiprenocl"), SV("ashjd"), 0, S::npos);
+ test(S("litpcfdghe"), SV("mgojkldsqh"), 0, S::npos);
+ test(S("aidjksrolc"), SV("imqnaghkfrdtlopbjesc"), 0, S::npos);
+ test(S("qpghtfbaji"), SV(""), 1, 1);
+ test(S("gfshlcmdjr"), SV("nadkh"), 1, 1);
+ test(S("nkodajteqp"), SV("ofdrqmkebl"), 1, 0);
+ test(S("gbmetiprqd"), SV("bdfjqgatlksriohemnpc"), 1, S::npos);
+ test(S("crnklpmegd"), SV(""), 5, 5);
+ test(S("jsbtafedoc"), SV("prqgn"), 5, 5);
+ test(S("qnmodrtkeb"), SV("pejafmnokr"), 5, 4);
+ test(S("cpebqsfmnj"), SV("odnqkgijrhabfmcestlp"), 5, S::npos);
+ test(S("lmofqdhpki"), SV(""), 9, 9);
+ test(S("hnefkqimca"), SV("rtjpa"), 9, 8);
+ test(S("drtasbgmfp"), SV("ktsrmnqagd"), 9, 9);
+ test(S("lsaijeqhtr"), SV("rtdhgcisbnmoaqkfpjle"), 9, S::npos);
+ test(S("elgofjmbrq"), SV(""), 10, 9);
+ test(S("mjqdgalkpc"), SV("dplqa"), 10, 9);
+ test(S("kthqnfcerm"), SV("dkacjoptns"), 10, 9);
+ test(S("dfsjhanorc"), SV("hqfimtrgnbekpdcsjalo"), 10, S::npos);
+ test(S("eqsgalomhb"), SV(""), 11, 9);
+ test(S("akiteljmoh"), SV("lofbc"), 11, 9);
+ test(S("hlbdfreqjo"), SV("astoegbfpn"), 11, 8);
+ test(S("taqobhlerg"), SV("pdgreqomsncafklhtibj"), 11, S::npos);
+ test(S("snafbdlghrjkpqtoceim"), SV(""), 0, 0);
+ test(S("aemtbrgcklhndjisfpoq"), SV("lbtqd"), 0, 0);
+ test(S("pnracgfkjdiholtbqsem"), SV("tboimldpjh"), 0, S::npos);
+ test(S("dicfltehbsgrmojnpkaq"), SV("slcerthdaiqjfnobgkpm"), 0, S::npos);
+ test(S("jlnkraeodhcspfgbqitm"), SV(""), 1, 1);
+ test(S("lhosrngtmfjikbqpcade"), SV("aqibs"), 1, 1);
+ test(S("rbtaqjhgkneisldpmfoc"), SV("gtfblmqinc"), 1, 0);
+ test(S("gpifsqlrdkbonjtmheca"), SV("mkqpbtdalgniorhfescj"), 1, S::npos);
+ test(S("hdpkobnsalmcfijregtq"), SV(""), 10, 10);
+ test(S("jtlshdgqaiprkbcoenfm"), SV("pblas"), 10, 9);
+ test(S("fkdrbqltsgmcoiphneaj"), SV("arosdhcfme"), 10, 9);
+ test(S("crsplifgtqedjohnabmk"), SV("blkhjeogicatqfnpdmsr"), 10, S::npos);
+ test(S("niptglfbosehkamrdqcj"), SV(""), 19, 19);
+ test(S("copqdhstbingamjfkler"), SV("djkqc"), 19, 19);
+ test(S("mrtaefilpdsgocnhqbjk"), SV("lgokshjtpb"), 19, 16);
+ test(S("kojatdhlcmigpbfrqnes"), SV("bqjhtkfepimcnsgrlado"), 19, S::npos);
+ test(S("eaintpchlqsbdgrkjofm"), SV(""), 20, 19);
+ test(S("gjnhidfsepkrtaqbmclo"), SV("nocfa"), 20, 18);
+ test(S("spocfaktqdbiejlhngmr"), SV("bgtajmiedc"), 20, 19);
+ test(S("rphmlekgfscndtaobiqj"), SV("lsckfnqgdahejiopbtmr"), 20, S::npos);
+ test(S("liatsqdoegkmfcnbhrpj"), SV(""), 21, 19);
+ test(S("binjagtfldkrspcomqeh"), SV("gfsrt"), 21, 19);
+ test(S("latkmisecnorjbfhqpdg"), SV("pfsocbhjtm"), 21, 19);
+ test(S("lecfratdjkhnsmqpoigb"), SV("tpflmdnoicjgkberhqsa"), 21, S::npos);
+}
+
+template <class S, class SV>
+void test1()
+{
+ test(S(""), SV(""), S::npos);
+ test(S(""), SV("laenf"), S::npos);
+ test(S(""), SV("pqlnkmbdjo"), S::npos);
+ test(S(""), SV("qkamfogpnljdcshbreti"), S::npos);
+ test(S("nhmko"), SV(""), 4);
+ test(S("lahfb"), SV("irkhs"), 4);
+ test(S("gmfhd"), SV("kantesmpgj"), 4);
+ test(S("odaft"), SV("oknlrstdpiqmjbaghcfe"), S::npos);
+ test(S("eolhfgpjqk"), SV(""), 9);
+ test(S("nbatdlmekr"), SV("bnrpe"), 8);
+ test(S("jdmciepkaq"), SV("jtdaefblso"), 9);
+ test(S("hkbgspoflt"), SV("oselktgbcapndfjihrmq"), S::npos);
+ test(S("gprdcokbnjhlsfmtieqa"), SV(""), 19);
+ test(S("qjghlnftcaismkropdeb"), SV("bjaht"), 18);
+ test(S("pnalfrdtkqcmojiesbhg"), SV("hjlcmgpket"), 17);
+ test(S("pniotcfrhqsmgdkjbael"), SV("htaobedqikfplcgjsmrn"), S::npos);
+}
+
+int main()
+{
+ {
+ typedef std::string S;
+ typedef std::string_view SV;
+ test0<S, SV>();
+ test1<S, SV>();
+ }
+#if TEST_STD_VER >= 11
+ {
+// typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+// typedef std::string_view SV;
+// test0<S, SV>();
+// test1<S, SV>();
+ }
+#endif
+}
diff --git a/test/std/strings/basic.string/string.ops/string_find.last.of/string_view_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.last.of/string_view_size.pass.cpp
new file mode 100644
index 0000000..fb8ca34
--- /dev/null
+++ b/test/std/strings/basic.string/string.ops/string_find.last.of/string_view_size.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <string>
+
+// size_type find_last_of(const basic_string_view sv, size_type pos = npos) const;
+
+#include <string>
+#include <cassert>
+
+#include "min_allocator.h"
+
+template <class S, class SV>
+void
+test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
+{
+ assert(s.find_last_of(sv, pos) == x);
+ if (x != S::npos)
+ assert(x <= pos && x < s.size());
+}
+
+template <class S, class SV>
+void
+test(const S& s, SV sv, typename S::size_type x)
+{
+ assert(s.find_last_of(sv) == x);
+ if (x != S::npos)
+ assert(x < s.size());
+}
+
+template <class S, class SV>
+void test0()
+{
+ test(S(""), SV(""), 0, S::npos);
+ test(S(""), SV("laenf"), 0, S::npos);
+ test(S(""), SV("pqlnkmbdjo"), 0, S::npos);
+ test(S(""), SV("qkamfogpnljdcshbreti"), 0, S::npos);
+ test(S(""), SV(""), 1, S::npos);
+ test(S(""), SV("bjaht"), 1, S::npos);
+ test(S(""), SV("hjlcmgpket"), 1, S::npos);
+ test(S(""), SV("htaobedqikfplcgjsmrn"), 1, S::npos);
+ test(S("fodgq"), SV(""), 0, S::npos);
+ test(S("qanej"), SV("dfkap"), 0, S::npos);
+ test(S("clbao"), SV("ihqrfebgad"), 0, S::npos);
+ test(S("mekdn"), SV("ngtjfcalbseiqrphmkdo"), 0, 0);
+ test(S("srdfq"), SV(""), 1, S::npos);
+ test(S("oemth"), SV("ikcrq"), 1, S::npos);
+ test(S("cdaih"), SV("dmajblfhsg"), 1, 1);
+ test(S("qohtk"), SV("oqftjhdmkgsblacenirp"), 1, 1);
+ test(S("cshmd"), SV(""), 2, S::npos);
+ test(S("lhcdo"), SV("oebqi"), 2, S::npos);
+ test(S("qnsoh"), SV("kojhpmbsfe"), 2, 2);
+ test(S("pkrof"), SV("acbsjqogpltdkhinfrem"), 2, 2);
+ test(S("fmtsp"), SV(""), 4, S::npos);
+ test(S("khbpm"), SV("aobjd"), 4, 2);
+ test(S("pbsji"), SV("pcbahntsje"), 4, 3);
+ test(S("mprdj"), SV("fhepcrntkoagbmldqijs"), 4, 4);
+ test(S("eqmpa"), SV(""), 5, S::npos);
+ test(S("omigs"), SV("kocgb"), 5, 3);
+ test(S("onmje"), SV("fbslrjiqkm"), 5, 3);
+ test(S("oqmrj"), SV("jeidpcmalhfnqbgtrsko"), 5, 4);
+ test(S("schfa"), SV(""), 6, S::npos);
+ test(S("igdsc"), SV("qngpd"), 6, 2);
+ test(S("brqgo"), SV("rodhqklgmb"), 6, 4);
+ test(S("tnrph"), SV("thdjgafrlbkoiqcspmne"), 6, 4);
+ test(S("hcjitbfapl"), SV(""), 0, S::npos);
+ test(S("daiprenocl"), SV("ashjd"), 0, 0);
+ test(S("litpcfdghe"), SV("mgojkldsqh"), 0, 0);
+ test(S("aidjksrolc"), SV("imqnaghkfrdtlopbjesc"), 0, 0);
+ test(S("qpghtfbaji"), SV(""), 1, S::npos);
+ test(S("gfshlcmdjr"), SV("nadkh"), 1, S::npos);
+ test(S("nkodajteqp"), SV("ofdrqmkebl"), 1, 1);
+ test(S("gbmetiprqd"), SV("bdfjqgatlksriohemnpc"), 1, 1);
+ test(S("crnklpmegd"), SV(""), 5, S::npos);
+ test(S("jsbtafedoc"), SV("prqgn"), 5, S::npos);
+ test(S("qnmodrtkeb"), SV("pejafmnokr"), 5, 5);
+ test(S("cpebqsfmnj"), SV("odnqkgijrhabfmcestlp"), 5, 5);
+ test(S("lmofqdhpki"), SV(""), 9, S::npos);
+ test(S("hnefkqimca"), SV("rtjpa"), 9, 9);
+ test(S("drtasbgmfp"), SV("ktsrmnqagd"), 9, 7);
+ test(S("lsaijeqhtr"), SV("rtdhgcisbnmoaqkfpjle"), 9, 9);
+ test(S("elgofjmbrq"), SV(""), 10, S::npos);
+ test(S("mjqdgalkpc"), SV("dplqa"), 10, 8);
+ test(S("kthqnfcerm"), SV("dkacjoptns"), 10, 6);
+ test(S("dfsjhanorc"), SV("hqfimtrgnbekpdcsjalo"), 10, 9);
+ test(S("eqsgalomhb"), SV(""), 11, S::npos);
+ test(S("akiteljmoh"), SV("lofbc"), 11, 8);
+ test(S("hlbdfreqjo"), SV("astoegbfpn"), 11, 9);
+ test(S("taqobhlerg"), SV("pdgreqomsncafklhtibj"), 11, 9);
+ test(S("snafbdlghrjkpqtoceim"), SV(""), 0, S::npos);
+ test(S("aemtbrgcklhndjisfpoq"), SV("lbtqd"), 0, S::npos);
+ test(S("pnracgfkjdiholtbqsem"), SV("tboimldpjh"), 0, 0);
+ test(S("dicfltehbsgrmojnpkaq"), SV("slcerthdaiqjfnobgkpm"), 0, 0);
+ test(S("jlnkraeodhcspfgbqitm"), SV(""), 1, S::npos);
+ test(S("lhosrngtmfjikbqpcade"), SV("aqibs"), 1, S::npos);
+ test(S("rbtaqjhgkneisldpmfoc"), SV("gtfblmqinc"), 1, 1);
+ test(S("gpifsqlrdkbonjtmheca"), SV("mkqpbtdalgniorhfescj"), 1, 1);
+ test(S("hdpkobnsalmcfijregtq"), SV(""), 10, S::npos);
+ test(S("jtlshdgqaiprkbcoenfm"), SV("pblas"), 10, 10);
+ test(S("fkdrbqltsgmcoiphneaj"), SV("arosdhcfme"), 10, 10);
+ test(S("crsplifgtqedjohnabmk"), SV("blkhjeogicatqfnpdmsr"), 10, 10);
+ test(S("niptglfbosehkamrdqcj"), SV(""), 19, S::npos);
+ test(S("copqdhstbingamjfkler"), SV("djkqc"), 19, 16);
+ test(S("mrtaefilpdsgocnhqbjk"), SV("lgokshjtpb"), 19, 19);
+ test(S("kojatdhlcmigpbfrqnes"), SV("bqjhtkfepimcnsgrlado"), 19, 19);
+ test(S("eaintpchlqsbdgrkjofm"), SV(""), 20, S::npos);
+ test(S("gjnhidfsepkrtaqbmclo"), SV("nocfa"), 20, 19);
+ test(S("spocfaktqdbiejlhngmr"), SV("bgtajmiedc"), 20, 18);
+ test(S("rphmlekgfscndtaobiqj"), SV("lsckfnqgdahejiopbtmr"), 20, 19);
+ test(S("liatsqdoegkmfcnbhrpj"), SV(""), 21, S::npos);
+ test(S("binjagtfldkrspcomqeh"), SV("gfsrt"), 21, 12);
+ test(S("latkmisecnorjbfhqpdg"), SV("pfsocbhjtm"), 21, 17);
+ test(S("lecfratdjkhnsmqpoigb"), SV("tpflmdnoicjgkberhqsa"), 21, 19);
+}
+
+template <class S, class SV>
+void test1()
+{
+ test(S(""), SV(""), S::npos);
+ test(S(""), SV("laenf"), S::npos);
+ test(S(""), SV("pqlnkmbdjo"), S::npos);
+ test(S(""), SV("qkamfogpnljdcshbreti"), S::npos);
+ test(S("nhmko"), SV(""), S::npos);
+ test(S("lahfb"), SV("irkhs"), 2);
+ test(S("gmfhd"), SV("kantesmpgj"), 1);
+ test(S("odaft"), SV("oknlrstdpiqmjbaghcfe"), 4);
+ test(S("eolhfgpjqk"), SV(""), S::npos);
+ test(S("nbatdlmekr"), SV("bnrpe"), 9);
+ test(S("jdmciepkaq"), SV("jtdaefblso"), 8);
+ test(S("hkbgspoflt"), SV("oselktgbcapndfjihrmq"), 9);
+ test(S("gprdcokbnjhlsfmtieqa"), SV(""), S::npos);
+ test(S("qjghlnftcaismkropdeb"), SV("bjaht"), 19);
+ test(S("pnalfrdtkqcmojiesbhg"), SV("hjlcmgpket"), 19);
+ test(S("pniotcfrhqsmgdkjbael"), SV("htaobedqikfplcgjsmrn"), 19);
+}
+
+int main()
+{
+ {
+ typedef std::string S;
+ typedef std::string_view SV;
+ test0<S, SV>();
+ test1<S, SV>();
+ }
+#if TEST_STD_VER >= 11
+ {
+ typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+ typedef std::string_view SV;
+ test0<S, SV>();
+ test1<S, SV>();
+ }
+#endif
+}
diff --git a/test/std/strings/basic.string/string.ops/string_find/string_view_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find/string_view_size.pass.cpp
new file mode 100644
index 0000000..096f47e
--- /dev/null
+++ b/test/std/strings/basic.string/string.ops/string_find/string_view_size.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <string>
+
+// size_type find(basic_string_view sv, size_type pos = 0) const;
+
+#include <string>
+#include <cassert>
+
+#include "min_allocator.h"
+
+template <class S, class SV>
+void
+test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
+{
+ assert(s.find(sv, pos) == x);
+ if (x != S::npos)
+ assert(pos <= x && x + sv.size() <= s.size());
+}
+
+template <class S, class SV>
+void
+test(const S& s, SV sv, typename S::size_type x)
+{
+ assert(s.find(sv) == x);
+ if (x != S::npos)
+ assert(0 <= x && x + sv.size() <= s.size());
+}
+
+template <class S, class SV>
+void test0()
+{
+ test(S(""), SV(""), 0, 0);
+ test(S(""), SV("abcde"), 0, S::npos);
+ test(S(""), SV("abcdeabcde"), 0, S::npos);
+ test(S(""), SV("abcdeabcdeabcdeabcde"), 0, S::npos);
+ test(S(""), SV(""), 1, S::npos);
+ test(S(""), SV("abcde"), 1, S::npos);
+ test(S(""), SV("abcdeabcde"), 1, S::npos);
+ test(S(""), SV("abcdeabcdeabcdeabcde"), 1, S::npos);
+ test(S("abcde"), SV(""), 0, 0);
+ test(S("abcde"), SV("abcde"), 0, 0);
+ test(S("abcde"), SV("abcdeabcde"), 0, S::npos);
+ test(S("abcde"), SV("abcdeabcdeabcdeabcde"), 0, S::npos);
+ test(S("abcde"), SV(""), 1, 1);
+ test(S("abcde"), SV("abcde"), 1, S::npos);
+ test(S("abcde"), SV("abcdeabcde"), 1, S::npos);
+ test(S("abcde"), SV("abcdeabcdeabcdeabcde"), 1, S::npos);
+ test(S("abcde"), SV(""), 2, 2);
+ test(S("abcde"), SV("abcde"), 2, S::npos);
+ test(S("abcde"), SV("abcdeabcde"), 2, S::npos);
+ test(S("abcde"), SV("abcdeabcdeabcdeabcde"), 2, S::npos);
+ test(S("abcde"), SV(""), 4, 4);
+ test(S("abcde"), SV("abcde"), 4, S::npos);
+ test(S("abcde"), SV("abcdeabcde"), 4, S::npos);
+ test(S("abcde"), SV("abcdeabcdeabcdeabcde"), 4, S::npos);
+ test(S("abcde"), SV(""), 5, 5);
+ test(S("abcde"), SV("abcde"), 5, S::npos);
+ test(S("abcde"), SV("abcdeabcde"), 5, S::npos);
+ test(S("abcde"), SV("abcdeabcdeabcdeabcde"), 5, S::npos);
+ test(S("abcde"), SV(""), 6, S::npos);
+ test(S("abcde"), SV("abcde"), 6, S::npos);
+ test(S("abcde"), SV("abcdeabcde"), 6, S::npos);
+ test(S("abcde"), SV("abcdeabcdeabcdeabcde"), 6, S::npos);
+ test(S("abcdeabcde"), SV(""), 0, 0);
+ test(S("abcdeabcde"), SV("abcde"), 0, 0);
+ test(S("abcdeabcde"), SV("abcdeabcde"), 0, 0);
+ test(S("abcdeabcde"), SV("abcdeabcdeabcdeabcde"), 0, S::npos);
+ test(S("abcdeabcde"), SV(""), 1, 1);
+ test(S("abcdeabcde"), SV("abcde"), 1, 5);
+ test(S("abcdeabcde"), SV("abcdeabcde"), 1, S::npos);
+ test(S("abcdeabcde"), SV("abcdeabcdeabcdeabcde"), 1, S::npos);
+ test(S("abcdeabcde"), SV(""), 5, 5);
+ test(S("abcdeabcde"), SV("abcde"), 5, 5);
+ test(S("abcdeabcde"), SV("abcdeabcde"), 5, S::npos);
+ test(S("abcdeabcde"), SV("abcdeabcdeabcdeabcde"), 5, S::npos);
+ test(S("abcdeabcde"), SV(""), 9, 9);
+ test(S("abcdeabcde"), SV("abcde"), 9, S::npos);
+ test(S("abcdeabcde"), SV("abcdeabcde"), 9, S::npos);
+ test(S("abcdeabcde"), SV("abcdeabcdeabcdeabcde"), 9, S::npos);
+ test(S("abcdeabcde"), SV(""), 10, 10);
+ test(S("abcdeabcde"), SV("abcde"), 10, S::npos);
+ test(S("abcdeabcde"), SV("abcdeabcde"), 10, S::npos);
+ test(S("abcdeabcde"), SV("abcdeabcdeabcdeabcde"), 10, S::npos);
+ test(S("abcdeabcde"), SV(""), 11, S::npos);
+ test(S("abcdeabcde"), SV("abcde"), 11, S::npos);
+ test(S("abcdeabcde"), SV("abcdeabcde"), 11, S::npos);
+ test(S("abcdeabcde"), SV("abcdeabcdeabcdeabcde"), 11, S::npos);
+ test(S("abcdeabcdeabcdeabcde"), SV(""), 0, 0);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcde"), 0, 0);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcde"), 0, 0);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 0, 0);
+ test(S("abcdeabcdeabcdeabcde"), SV(""), 1, 1);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcde"), 1, 5);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcde"), 1, 5);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 1, S::npos);
+ test(S("abcdeabcdeabcdeabcde"), SV(""), 10, 10);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcde"), 10, 10);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcde"), 10, 10);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 10, S::npos);
+ test(S("abcdeabcdeabcdeabcde"), SV(""), 19, 19);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcde"), 19, S::npos);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcde"), 19, S::npos);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 19, S::npos);
+ test(S("abcdeabcdeabcdeabcde"), SV(""), 20, 20);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcde"), 20, S::npos);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcde"), 20, S::npos);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 20, S::npos);
+ test(S("abcdeabcdeabcdeabcde"), SV(""), 21, S::npos);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcde"), 21, S::npos);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcde"), 21, S::npos);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 21, S::npos);
+}
+
+template <class S, class SV>
+void test1()
+{
+ test(S(""), SV(""), 0);
+ test(S(""), SV("abcde"), S::npos);
+ test(S(""), SV("abcdeabcde"), S::npos);
+ test(S(""), SV("abcdeabcdeabcdeabcde"), S::npos);
+ test(S("abcde"), SV(""), 0);
+ test(S("abcde"), SV("abcde"), 0);
+ test(S("abcde"), SV("abcdeabcde"), S::npos);
+ test(S("abcde"), SV("abcdeabcdeabcdeabcde"), S::npos);
+ test(S("abcdeabcde"), SV(""), 0);
+ test(S("abcdeabcde"), SV("abcde"), 0);
+ test(S("abcdeabcde"), SV("abcdeabcde"), 0);
+ test(S("abcdeabcde"), SV("abcdeabcdeabcdeabcde"), S::npos);
+ test(S("abcdeabcdeabcdeabcde"), SV(""), 0);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcde"), 0);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcde"), 0);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 0);
+}
+
+int main()
+{
+ {
+ typedef std::string S;
+ typedef std::string_view SV;
+ test0<S, SV>();
+ test1<S, SV>();
+ }
+#if TEST_STD_VER >= 11
+ {
+ typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+ typedef std::string_view SV;
+ test0<S, SV>();
+ test1<S, SV>();
+ }
+#endif
+}
diff --git a/test/std/strings/basic.string/string.ops/string_rfind/string_view_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_rfind/string_view_size.pass.cpp
new file mode 100644
index 0000000..230c455
--- /dev/null
+++ b/test/std/strings/basic.string/string.ops/string_rfind/string_view_size.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <string>
+
+// size_type rfind(basic_string_view sv, size_type pos = npos) const;
+
+#include <string>
+#include <cassert>
+
+#include "min_allocator.h"
+
+template <class S, class SV>
+void
+test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
+{
+ assert(s.rfind(sv, pos) == x);
+ if (x != S::npos)
+ assert(x <= pos && x + sv.size() <= s.size());
+}
+
+template <class S, class SV>
+void
+test(const S& s, SV sv, typename S::size_type x)
+{
+ assert(s.rfind(sv) == x);
+ if (x != S::npos)
+ assert(0 <= x && x + sv.size() <= s.size());
+}
+
+template <class S, class SV>
+void test0()
+{
+ test(S(""), SV(""), 0, 0);
+ test(S(""), SV("abcde"), 0, S::npos);
+ test(S(""), SV("abcdeabcde"), 0, S::npos);
+ test(S(""), SV("abcdeabcdeabcdeabcde"), 0, S::npos);
+ test(S(""), SV(""), 1, 0);
+ test(S(""), SV("abcde"), 1, S::npos);
+ test(S(""), SV("abcdeabcde"), 1, S::npos);
+ test(S(""), SV("abcdeabcdeabcdeabcde"), 1, S::npos);
+ test(S("abcde"), SV(""), 0, 0);
+ test(S("abcde"), SV("abcde"), 0, 0);
+ test(S("abcde"), SV("abcdeabcde"), 0, S::npos);
+ test(S("abcde"), SV("abcdeabcdeabcdeabcde"), 0, S::npos);
+ test(S("abcde"), SV(""), 1, 1);
+ test(S("abcde"), SV("abcde"), 1, 0);
+ test(S("abcde"), SV("abcdeabcde"), 1, S::npos);
+ test(S("abcde"), SV("abcdeabcdeabcdeabcde"), 1, S::npos);
+ test(S("abcde"), SV(""), 2, 2);
+ test(S("abcde"), SV("abcde"), 2, 0);
+ test(S("abcde"), SV("abcdeabcde"), 2, S::npos);
+ test(S("abcde"), SV("abcdeabcdeabcdeabcde"), 2, S::npos);
+ test(S("abcde"), SV(""), 4, 4);
+ test(S("abcde"), SV("abcde"), 4, 0);
+ test(S("abcde"), SV("abcdeabcde"), 4, S::npos);
+ test(S("abcde"), SV("abcdeabcdeabcdeabcde"), 4, S::npos);
+ test(S("abcde"), SV(""), 5, 5);
+ test(S("abcde"), SV("abcde"), 5, 0);
+ test(S("abcde"), SV("abcdeabcde"), 5, S::npos);
+ test(S("abcde"), SV("abcdeabcdeabcdeabcde"), 5, S::npos);
+ test(S("abcde"), SV(""), 6, 5);
+ test(S("abcde"), SV("abcde"), 6, 0);
+ test(S("abcde"), SV("abcdeabcde"), 6, S::npos);
+ test(S("abcde"), SV("abcdeabcdeabcdeabcde"), 6, S::npos);
+ test(S("abcdeabcde"), SV(""), 0, 0);
+ test(S("abcdeabcde"), SV("abcde"), 0, 0);
+ test(S("abcdeabcde"), SV("abcdeabcde"), 0, 0);
+ test(S("abcdeabcde"), SV("abcdeabcdeabcdeabcde"), 0, S::npos);
+ test(S("abcdeabcde"), SV(""), 1, 1);
+ test(S("abcdeabcde"), SV("abcde"), 1, 0);
+ test(S("abcdeabcde"), SV("abcdeabcde"), 1, 0);
+ test(S("abcdeabcde"), SV("abcdeabcdeabcdeabcde"), 1, S::npos);
+ test(S("abcdeabcde"), SV(""), 5, 5);
+ test(S("abcdeabcde"), SV("abcde"), 5, 5);
+ test(S("abcdeabcde"), SV("abcdeabcde"), 5, 0);
+ test(S("abcdeabcde"), SV("abcdeabcdeabcdeabcde"), 5, S::npos);
+ test(S("abcdeabcde"), SV(""), 9, 9);
+ test(S("abcdeabcde"), SV("abcde"), 9, 5);
+ test(S("abcdeabcde"), SV("abcdeabcde"), 9, 0);
+ test(S("abcdeabcde"), SV("abcdeabcdeabcdeabcde"), 9, S::npos);
+ test(S("abcdeabcde"), SV(""), 10, 10);
+ test(S("abcdeabcde"), SV("abcde"), 10, 5);
+ test(S("abcdeabcde"), SV("abcdeabcde"), 10, 0);
+ test(S("abcdeabcde"), SV("abcdeabcdeabcdeabcde"), 10, S::npos);
+ test(S("abcdeabcde"), SV(""), 11, 10);
+ test(S("abcdeabcde"), SV("abcde"), 11, 5);
+ test(S("abcdeabcde"), SV("abcdeabcde"), 11, 0);
+ test(S("abcdeabcde"), SV("abcdeabcdeabcdeabcde"), 11, S::npos);
+ test(S("abcdeabcdeabcdeabcde"), SV(""), 0, 0);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcde"), 0, 0);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcde"), 0, 0);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 0, 0);
+ test(S("abcdeabcdeabcdeabcde"), SV(""), 1, 1);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcde"), 1, 0);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcde"), 1, 0);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 1, 0);
+ test(S("abcdeabcdeabcdeabcde"), SV(""), 10, 10);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcde"), 10, 10);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcde"), 10, 10);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 10, 0);
+ test(S("abcdeabcdeabcdeabcde"), SV(""), 19, 19);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcde"), 19, 15);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcde"), 19, 10);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 19, 0);
+ test(S("abcdeabcdeabcdeabcde"), SV(""), 20, 20);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcde"), 20, 15);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcde"), 20, 10);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 20, 0);
+ test(S("abcdeabcdeabcdeabcde"), SV(""), 21, 20);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcde"), 21, 15);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcde"), 21, 10);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 21, 0);
+}
+
+template <class S, class SV>
+void test1()
+{
+ test(S(""), SV(""), 0);
+ test(S(""), SV("abcde"), S::npos);
+ test(S(""), SV("abcdeabcde"), S::npos);
+ test(S(""), SV("abcdeabcdeabcdeabcde"), S::npos);
+ test(S("abcde"), SV(""), 5);
+ test(S("abcde"), SV("abcde"), 0);
+ test(S("abcde"), SV("abcdeabcde"), S::npos);
+ test(S("abcde"), SV("abcdeabcdeabcdeabcde"), S::npos);
+ test(S("abcdeabcde"), SV(""), 10);
+ test(S("abcdeabcde"), SV("abcde"), 5);
+ test(S("abcdeabcde"), SV("abcdeabcde"), 0);
+ test(S("abcdeabcde"), SV("abcdeabcdeabcdeabcde"), S::npos);
+ test(S("abcdeabcdeabcdeabcde"), SV(""), 20);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcde"), 15);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcde"), 10);
+ test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 0);
+}
+
+int main()
+{
+ {
+ typedef std::string S;
+ typedef std::string_view SV;
+ test0<S, SV>();
+ test1<S, SV>();
+ }
+#if TEST_STD_VER >= 11
+ {
+ typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+ typedef std::string_view SV;
+ test0<S, SV>();
+ test1<S, SV>();
+ }
+#endif
+}
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 9b55234..4cf2b0a 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,16 +18,16 @@
int main()
{
- assert( std::char_traits<char>::lt('\0', 'A'));
- assert(!std::char_traits<char>::lt('A', '\0'));
+ 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', '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', 'z'));
+ assert( std::char_traits<char>::lt('A', 'Z'));
- assert( std::char_traits<char>::lt(' ', 'A'));
- assert( std::char_traits<char>::lt('A', '~'));
+ assert( std::char_traits<char>::lt(' ', 'A'));
+ assert( std::char_traits<char>::lt('A', '~'));
}
diff --git a/test/std/strings/string.view/string.view.cons/from_string1.fail.cpp b/test/std/strings/string.view/string.view.cons/from_string1.fail.cpp
index 0f33dd8..006bea7 100644
--- a/test/std/strings/string.view/string.view.cons/from_string1.fail.cpp
+++ b/test/std/strings/string.view/string.view.cons/from_string1.fail.cpp
@@ -29,4 +29,4 @@
assert ( sv1.size() == s.size());
assert ( sv1.data() == s.data());
}
-}
\ No newline at end of file
+}
diff --git a/test/std/thread/futures/futures.async/async_race.pass.cpp b/test/std/thread/futures/futures.async/async_race.pass.cpp
index 9acdd1a..1189f35 100644
--- a/test/std/thread/futures/futures.async/async_race.pass.cpp
+++ b/test/std/thread/futures/futures.async/async_race.pass.cpp
@@ -21,7 +21,7 @@
// async(launch policy, F&& f, Args&&... args);
// This test is designed to cause and allow TSAN to detect the race condition
-// reported in PR23293. (http://llvm.org/PR23293).
+// reported in PR23293: https://bugs.llvm.org/show_bug.cgi?id=23293
#include <future>
#include <chrono>
diff --git a/test/std/thread/futures/futures.shared_future/wait_until.pass.cpp b/test/std/thread/futures/futures.shared_future/wait_until.pass.cpp
index 9cdc2e4..0ddbd0b 100644
--- a/test/std/thread/futures/futures.shared_future/wait_until.pass.cpp
+++ b/test/std/thread/futures/futures.shared_future/wait_until.pass.cpp
@@ -1,130 +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.
- //
- //===----------------------------------------------------------------------===//
- //
- // UNSUPPORTED: libcpp-has-no-threads
- // UNSUPPORTED: c++98, c++03
+//===----------------------------------------------------------------------===//
+//
+// The 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
- // <future>
+// <future>
- // class shared_future<R>
+// class shared_future<R>
- // template <class Clock, class Duration>
- // future_status
- // wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
+// template <class Clock, class Duration>
+// future_status
+// wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
- #include <future>
- #include <atomic>
- #include <cassert>
+#include <future>
+#include <atomic>
+#include <cassert>
- enum class WorkerThreadState { Uninitialized, AllowedToRun, Exiting };
- typedef std::chrono::milliseconds ms;
+enum class WorkerThreadState { Uninitialized, AllowedToRun, Exiting };
+typedef std::chrono::milliseconds ms;
- std::atomic<WorkerThreadState> thread_state(WorkerThreadState::Uninitialized);
+std::atomic<WorkerThreadState> thread_state(WorkerThreadState::Uninitialized);
- void set_worker_thread_state(WorkerThreadState state)
- {
- thread_state.store(state, std::memory_order_relaxed);
- }
+void set_worker_thread_state(WorkerThreadState state)
+{
+ thread_state.store(state, std::memory_order_relaxed);
+}
- void wait_for_worker_thread_state(WorkerThreadState state)
- {
- while (thread_state.load(std::memory_order_relaxed) != state);
- }
+void wait_for_worker_thread_state(WorkerThreadState state)
+{
+ while (thread_state.load(std::memory_order_relaxed) != state);
+}
- void func1(std::promise<int> p)
- {
- wait_for_worker_thread_state(WorkerThreadState::AllowedToRun);
- p.set_value(3);
- set_worker_thread_state(WorkerThreadState::Exiting);
- }
+void func1(std::promise<int> p)
+{
+ wait_for_worker_thread_state(WorkerThreadState::AllowedToRun);
+ p.set_value(3);
+ set_worker_thread_state(WorkerThreadState::Exiting);
+}
- int j = 0;
+int j = 0;
- void func3(std::promise<int&> p)
- {
- wait_for_worker_thread_state(WorkerThreadState::AllowedToRun);
- j = 5;
- p.set_value(j);
- set_worker_thread_state(WorkerThreadState::Exiting);
- }
+void func3(std::promise<int&> p)
+{
+ wait_for_worker_thread_state(WorkerThreadState::AllowedToRun);
+ j = 5;
+ p.set_value(j);
+ set_worker_thread_state(WorkerThreadState::Exiting);
+}
- void func5(std::promise<void> p)
- {
- wait_for_worker_thread_state(WorkerThreadState::AllowedToRun);
- p.set_value();
- set_worker_thread_state(WorkerThreadState::Exiting);
- }
+void func5(std::promise<void> p)
+{
+ wait_for_worker_thread_state(WorkerThreadState::AllowedToRun);
+ p.set_value();
+ set_worker_thread_state(WorkerThreadState::Exiting);
+}
- int main()
- {
- typedef std::chrono::high_resolution_clock Clock;
- {
- typedef int T;
- std::promise<T> p;
- std::shared_future<T> f = p.get_future();
- std::thread(func1, std::move(p)).detach();
- assert(f.valid());
- assert(f.wait_until(Clock::now() + ms(10)) == std::future_status::timeout);
- assert(f.valid());
+int main()
+{
+ typedef std::chrono::high_resolution_clock Clock;
+ {
+ typedef int T;
+ std::promise<T> p;
+ std::shared_future<T> f = p.get_future();
+ std::thread(func1, std::move(p)).detach();
+ assert(f.valid());
+ assert(f.wait_until(Clock::now() + ms(10)) == std::future_status::timeout);
+ assert(f.valid());
- // allow the worker thread to produce the result and wait until the worker is done
- set_worker_thread_state(WorkerThreadState::AllowedToRun);
- wait_for_worker_thread_state(WorkerThreadState::Exiting);
+ // allow the worker thread to produce the result and wait until the worker is done
+ set_worker_thread_state(WorkerThreadState::AllowedToRun);
+ wait_for_worker_thread_state(WorkerThreadState::Exiting);
- assert(f.wait_until(Clock::now() + ms(10)) == std::future_status::ready);
- assert(f.valid());
- Clock::time_point t0 = Clock::now();
- f.wait();
- Clock::time_point t1 = Clock::now();
- assert(f.valid());
- assert(t1-t0 < ms(5));
- }
- {
- typedef int& T;
- std::promise<T> p;
- std::shared_future<T> f = p.get_future();
- std::thread(func3, std::move(p)).detach();
- assert(f.valid());
- assert(f.wait_until(Clock::now() + ms(10)) == std::future_status::timeout);
- assert(f.valid());
+ assert(f.wait_until(Clock::now() + ms(10)) == std::future_status::ready);
+ assert(f.valid());
+ Clock::time_point t0 = Clock::now();
+ f.wait();
+ Clock::time_point t1 = Clock::now();
+ assert(f.valid());
+ assert(t1-t0 < ms(5));
+ }
+ {
+ typedef int& T;
+ std::promise<T> p;
+ std::shared_future<T> f = p.get_future();
+ std::thread(func3, std::move(p)).detach();
+ assert(f.valid());
+ assert(f.wait_until(Clock::now() + ms(10)) == std::future_status::timeout);
+ assert(f.valid());
- // allow the worker thread to produce the result and wait until the worker is done
- set_worker_thread_state(WorkerThreadState::AllowedToRun);
- wait_for_worker_thread_state(WorkerThreadState::Exiting);
+ // allow the worker thread to produce the result and wait until the worker is done
+ set_worker_thread_state(WorkerThreadState::AllowedToRun);
+ wait_for_worker_thread_state(WorkerThreadState::Exiting);
- assert(f.wait_until(Clock::now() + ms(10)) == std::future_status::ready);
- assert(f.valid());
- Clock::time_point t0 = Clock::now();
- f.wait();
- Clock::time_point t1 = Clock::now();
- assert(f.valid());
- assert(t1-t0 < ms(5));
- }
- {
- typedef void T;
- std::promise<T> p;
- std::shared_future<T> f = p.get_future();
- std::thread(func5, std::move(p)).detach();
- assert(f.valid());
- assert(f.wait_until(Clock::now() + ms(10)) == std::future_status::timeout);
- assert(f.valid());
+ assert(f.wait_until(Clock::now() + ms(10)) == std::future_status::ready);
+ assert(f.valid());
+ Clock::time_point t0 = Clock::now();
+ f.wait();
+ Clock::time_point t1 = Clock::now();
+ assert(f.valid());
+ assert(t1-t0 < ms(5));
+ }
+ {
+ typedef void T;
+ std::promise<T> p;
+ std::shared_future<T> f = p.get_future();
+ std::thread(func5, std::move(p)).detach();
+ assert(f.valid());
+ assert(f.wait_until(Clock::now() + ms(10)) == std::future_status::timeout);
+ assert(f.valid());
- // allow the worker thread to produce the result and wait until the worker is done
- set_worker_thread_state(WorkerThreadState::AllowedToRun);
- wait_for_worker_thread_state(WorkerThreadState::Exiting);
+ // allow the worker thread to produce the result and wait until the worker is done
+ set_worker_thread_state(WorkerThreadState::AllowedToRun);
+ wait_for_worker_thread_state(WorkerThreadState::Exiting);
- assert(f.wait_until(Clock::now() + ms(10)) == std::future_status::ready);
- assert(f.valid());
- Clock::time_point t0 = Clock::now();
- f.wait();
- Clock::time_point t1 = Clock::now();
- assert(f.valid());
- assert(t1-t0 < ms(5));
- }
- }
+ assert(f.wait_until(Clock::now() + ms(10)) == std::future_status::ready);
+ assert(f.valid());
+ Clock::time_point t0 = Clock::now();
+ f.wait();
+ Clock::time_point t1 = Clock::now();
+ assert(f.valid());
+ assert(t1-t0 < ms(5));
+ }
+}
diff --git a/test/std/thread/futures/futures.task/futures.task.members/ctor2.fail.cpp b/test/std/thread/futures/futures.task/futures.task.members/ctor2.fail.cpp
index 984dcdc..212a120 100644
--- a/test/std/thread/futures/futures.task/futures.task.members/ctor2.fail.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/ctor2.fail.cpp
@@ -30,5 +30,5 @@
int main()
{
PT p { std::allocator_arg_t{}, test_allocator<A>{}, VPT {}}; // expected-error {{no matching constructor for initialization of 'PT' (aka 'packaged_task<A (int, char)>')}}
- // expected-note@future:* 1 {{candidate template ignored: disabled by 'enable_if'}}
+ // expected-note-re@future:* 1 {{candidate template ignored: {{(disabled by 'enable_if')|(requirement '.*' was not satisfied)}}}}
}
diff --git a/test/std/thread/futures/futures.task/futures.task.members/ctor_func_alloc.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/ctor_func_alloc.pass.cpp
index 7cac21d..14b2971 100644
--- a/test/std/thread/futures/futures.task/futures.task.members/ctor_func_alloc.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/ctor_func_alloc.pass.cpp
@@ -9,6 +9,8 @@
//
// UNSUPPORTED: libcpp-has-no-threads
// UNSUPPORTED: c++98, c++03
+// REQUIRES: c++11 || c++14
+// packaged_task allocator support was removed in C++17 (LWG 2921)
// <future>
diff --git a/test/std/thread/futures/futures.task/futures.task.nonmembers/uses_allocator.pass.cpp b/test/std/thread/futures/futures.task/futures.task.nonmembers/uses_allocator.pass.cpp
index bbe75de..31ed57e 100644
--- a/test/std/thread/futures/futures.task/futures.task.nonmembers/uses_allocator.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.nonmembers/uses_allocator.pass.cpp
@@ -16,6 +16,8 @@
// XFAIL: c++98, c++03
// <future>
+// REQUIRES: c++11 || c++14
+// packaged_task allocator support was removed in C++17 (LWG 2976)
// class packaged_task<R(ArgTypes...)>
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/adopt_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/adopt_lock.pass.cpp
index 7816538..d49ba8d 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/adopt_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/adopt_lock.pass.cpp
@@ -14,7 +14,7 @@
// template <class ...Mutex> class scoped_lock;
-// scoped_lock(Mutex&..., adopt_lock_t);
+// scoped_lock(adopt_lock_t, Mutex&...);
#include <mutex>
#include <cassert>
@@ -43,7 +43,7 @@
using LG = std::scoped_lock<TestMutex>;
m1.lock();
{
- LG lg(m1, std::adopt_lock);
+ LG lg(std::adopt_lock, m1);
assert(m1.locked);
}
assert(!m1.locked);
@@ -53,7 +53,7 @@
using LG = std::scoped_lock<TestMutex, TestMutex>;
m1.lock(); m2.lock();
{
- LG lg(m1, m2, std::adopt_lock);
+ LG lg(std::adopt_lock, m1, m2);
assert(m1.locked && m2.locked);
}
assert(!m1.locked && !m2.locked);
@@ -63,7 +63,7 @@
using LG = std::scoped_lock<TestMutex, TestMutex, TestMutex>;
m1.lock(); m2.lock(); m3.lock();
{
- LG lg(m1, m2, m3, std::adopt_lock);
+ LG lg(std::adopt_lock, m1, m2, m3);
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.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 bd707bb..ee36e84 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
@@ -25,8 +25,8 @@
{
{
typedef std::shared_timed_mutex M;
- M m0;
- M m1;
+ M m0;
+ M m1;
std::shared_lock<M> lk0(m0);
std::shared_lock<M> lk1(m1);
lk1 = std::move(lk0);
@@ -37,8 +37,8 @@
}
{
typedef nasty_mutex M;
- M m0;
- M m1;
+ M m0;
+ M m1;
std::shared_lock<M> lk0(m0);
std::shared_lock<M> lk1(m1);
lk1 = std::move(lk0);
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 8d864ea..4ecd6c0 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
@@ -20,8 +20,8 @@
{
{
typedef std::mutex M;
- M m0;
- M m1;
+ M m0;
+ M m1;
std::unique_lock<M> lk0(m0);
std::unique_lock<M> lk1(m1);
lk1 = lk0;
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 6f17383..2d5feab 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
@@ -23,8 +23,8 @@
{
{
typedef std::mutex M;
- M m0;
- M m1;
+ M m0;
+ M m1;
std::unique_lock<M> lk0(m0);
std::unique_lock<M> lk1(m1);
lk1 = std::move(lk0);
@@ -35,8 +35,8 @@
}
{
typedef nasty_mutex M;
- M m0;
- M m1;
+ M m0;
+ M m1;
std::unique_lock<M> lk0(m0);
std::unique_lock<M> lk1(m1);
lk1 = std::move(lk0);
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex.pass.cpp
index ca8bc69..dcfdfd1 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex.pass.cpp
@@ -54,7 +54,7 @@
t.join();
#ifdef __cpp_deduction_guides
- std::unique_lock ul(m);
+ std::unique_lock ul(m);
static_assert((std::is_same<decltype(ul), std::unique_lock<decltype(m)>>::value), "" );
#endif
}
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/default.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/default.pass.cpp
index c61a93a..3ac9015 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/default.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/default.pass.cpp
@@ -8,7 +8,7 @@
//===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
-// UNSUPPORTED: c++03, c++98, c++11, c++14
+// 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/lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock.pass.cpp
index 0a6d6e3..efc4d32 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock.pass.cpp
@@ -8,7 +8,7 @@
//===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
-// UNSUPPORTED: c++03, c++98, c++11, c++14
+// UNSUPPORTED: c++98, c++03, c++11, c++14
// FLAKY_TEST.
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock_shared.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock_shared.pass.cpp
index b7edc50..72f74d5 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock_shared.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock_shared.pass.cpp
@@ -8,7 +8,7 @@
//===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
-// UNSUPPORTED: c++03, c++98, c++11, c++14
+// UNSUPPORTED: c++98, c++03, c++11, c++14
// FLAKY_TEST.
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock.pass.cpp
index 6f3ca24..f22f44c 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock.pass.cpp
@@ -8,7 +8,7 @@
//===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
-// UNSUPPORTED: c++03, c++98, c++11, c++14
+// 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/try_lock_shared.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock_shared.pass.cpp
index f615981..d2d486a 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock_shared.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock_shared.pass.cpp
@@ -8,7 +8,7 @@
//===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
-// UNSUPPORTED: c++03, c++98, c++11, c++14
+// UNSUPPORTED: c++98, c++03, c++11, c++14
// FLAKY_TEST.
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/default.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/default.pass.cpp
index 45cd563..a4e7670 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/default.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/default.pass.cpp
@@ -8,7 +8,7 @@
//===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
-// UNSUPPORTED: c++03, c++98, c++11
+// UNSUPPORTED: c++98, c++03, c++11
// <shared_mutex>
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock.pass.cpp
index 83979d4..0e173b0 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock.pass.cpp
@@ -8,7 +8,7 @@
//===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
-// UNSUPPORTED: c++03, c++98, c++11
+// UNSUPPORTED: c++98, c++03, c++11
// FLAKY_TEST.
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock_shared.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock_shared.pass.cpp
index 516f431..753d65d 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock_shared.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock_shared.pass.cpp
@@ -8,7 +8,7 @@
//===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
-// UNSUPPORTED: c++03, c++98, c++11
+// UNSUPPORTED: c++98, c++03, c++11
// FLAKY_TEST.
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock.pass.cpp
index 61900ba..fbe3cdc 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock.pass.cpp
@@ -8,7 +8,7 @@
//===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
-// UNSUPPORTED: c++03, c++98, c++11
+// UNSUPPORTED: c++98, c++03, c++11
// <shared_mutex>
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_for.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_for.pass.cpp
index 3d36911..e562c99 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_for.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_for.pass.cpp
@@ -8,7 +8,7 @@
//===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
-// UNSUPPORTED: c++03, c++98, c++11
+// UNSUPPORTED: c++98, c++03, c++11
// FLAKY_TEST.
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared.pass.cpp
index 452fc3c..b5fdbde 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared.pass.cpp
@@ -8,7 +8,7 @@
//===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
-// UNSUPPORTED: c++03, c++98, c++11
+// UNSUPPORTED: c++98, c++03, c++11
// FLAKY_TEST.
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_for.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_for.pass.cpp
index f478a29..69d71bf 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_for.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_for.pass.cpp
@@ -8,7 +8,7 @@
//===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
-// UNSUPPORTED: c++03, c++98, c++11
+// UNSUPPORTED: c++98, c++03, c++11
// FLAKY_TEST.
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_until.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_until.pass.cpp
index f33edfc..ba135a9 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_until.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_until.pass.cpp
@@ -8,7 +8,7 @@
//===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
-// UNSUPPORTED: c++03, c++98, c++11
+// UNSUPPORTED: c++98, c++03, c++11
// FLAKY_TEST.
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until.pass.cpp
index d5715c7..559cf8f 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until.pass.cpp
@@ -8,7 +8,7 @@
//===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
-// UNSUPPORTED: c++03, c++98, c++11
+// UNSUPPORTED: c++98, c++03, c++11
// FLAKY_TEST.
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until_deadlock_bug.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until_deadlock_bug.pass.cpp
index ed28809..0caea1d 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until_deadlock_bug.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until_deadlock_bug.pass.cpp
@@ -8,7 +8,7 @@
//===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
-// UNSUPPORTED: c++03, c++98, c++11
+// UNSUPPORTED: c++98, c++03, c++11
// <shared_mutex>
diff --git a/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/default.pass.cpp b/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/default.pass.cpp
index 21011ed..62f1b78 100644
--- a/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/default.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/default.pass.cpp
@@ -20,10 +20,12 @@
{
{
std::once_flag f;
+ (void)f;
}
#if TEST_STD_VER >= 11
{
constexpr std::once_flag f;
+ (void)f;
}
#endif
}
diff --git a/test/std/thread/thread.threads/thread.thread.this/sleep_until.pass.cpp b/test/std/thread/thread.threads/thread.thread.this/sleep_until.pass.cpp
index 9f3941b..6b62202 100644
--- a/test/std/thread/thread.threads/thread.thread.this/sleep_until.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.this/sleep_until.pass.cpp
@@ -22,7 +22,6 @@
{
typedef std::chrono::system_clock Clock;
typedef Clock::time_point time_point;
- typedef Clock::duration duration;
std::chrono::milliseconds ms(500);
time_point t0 = Clock::now();
std::this_thread::sleep_until(t0 + ms);
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/allocs.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/allocs.pass.cpp
index 2aa19c6..f18ed6e 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/allocs.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/allocs.pass.cpp
@@ -111,7 +111,7 @@
{
static_assert(!std::is_convertible<A1<int>, A2<int>>::value, "");
static_assert(!std::is_convertible<
- std::scoped_allocator_adaptor<A1<int>>,
+ std::scoped_allocator_adaptor<A1<int>>,
std::scoped_allocator_adaptor<A2<int>>>::value, "");
}
}
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 f8a9ea0..44e8709 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
@@ -26,12 +26,12 @@
{
// sanity checks
static_assert( (std::is_same<
- std::allocator_traits<A1<int>>::is_always_equal, std::false_type>::value
- ), "" );
+ std::allocator_traits<A1<int>>::is_always_equal, std::false_type>::value
+ ), "" );
static_assert( (std::is_same<
- std::allocator_traits<min_allocator<int>>::is_always_equal, std::true_type>::value
- ), "" );
+ std::allocator_traits<min_allocator<int>>::is_always_equal, std::true_type>::value
+ ), "" );
// wrapping one allocator
static_assert(
diff --git a/test/std/utilities/any/any.nonmembers/any.cast/any_cast_request_invalid_value_category.fail.cpp b/test/std/utilities/any/any.nonmembers/any.cast/any_cast_request_invalid_value_category.fail.cpp
index 07578a2..9638521 100644
--- a/test/std/utilities/any/any.nonmembers/any.cast/any_cast_request_invalid_value_category.fail.cpp
+++ b/test/std/utilities/any/any.nonmembers/any.cast/any_cast_request_invalid_value_category.fail.cpp
@@ -25,12 +25,12 @@
void test_const_lvalue_cast_request_non_const_lvalue()
{
const any a;
- // expected-error@any:* {{static_assert failed "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
+ // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
// expected-error@any:* {{binding value of type 'const TestType' to reference to type 'TestType' drops 'const' qualifier}}
any_cast<TestType &>(a); // expected-note {{requested here}}
const any a2(42);
- // expected-error@any:* {{static_assert failed "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
+ // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
// expected-error@any:* {{binding value of type 'const int' to reference to type 'int' drops 'const' qualifier}}
any_cast<int&>(a2); // expected-note {{requested here}}
}
@@ -38,22 +38,22 @@
void test_lvalue_any_cast_request_rvalue()
{
any a;
- // expected-error@any:* {{static_assert failed "ValueType is required to be an lvalue reference or a CopyConstructible type"}}
+ // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be an lvalue reference or a CopyConstructible type"}}
any_cast<TestType &&>(a); // expected-note {{requested here}}
any a2(42);
- // expected-error@any:* {{static_assert failed "ValueType is required to be an lvalue reference or a CopyConstructible type"}}
+ // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be an lvalue reference or a CopyConstructible type"}}
any_cast<int&&>(a2); // expected-note {{requested here}}
}
void test_rvalue_any_cast_request_lvalue()
{
any a;
- // expected-error@any:* {{static_assert failed "ValueType is required to be an rvalue reference or a CopyConstructible type"}}
+ // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be an rvalue reference or a CopyConstructible type"}}
// expected-error@any:* {{non-const lvalue reference to type 'TestType' cannot bind to a temporary}}
any_cast<TestType &>(std::move(a)); // expected-note {{requested here}}
- // expected-error@any:* {{static_assert failed "ValueType is required to be an rvalue reference or a CopyConstructible type"}}
+ // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be an rvalue reference or a CopyConstructible type"}}
// expected-error@any:* {{non-const lvalue reference to type 'int' cannot bind to a temporary}}
any_cast<int&>(42);
}
diff --git a/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.fail.cpp b/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.fail.cpp
index 3f6955a..bad229d 100644
--- a/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.fail.cpp
+++ b/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.fail.cpp
@@ -29,18 +29,18 @@
any a;
// expected-error@any:* {{binding value of type 'const TestType' to reference to type 'TestType' drops 'const' qualifier}}
- // expected-error@any:* {{static_assert failed "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
+ // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
any_cast<TestType &>(static_cast<any const&>(a)); // expected-note {{requested here}}
// expected-error@any:* {{cannot cast from lvalue of type 'const TestType' to rvalue reference type 'TestType &&'; types are not compatible}}
- // expected-error@any:* {{static_assert failed "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
+ // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
any_cast<TestType &&>(static_cast<any const&>(a)); // expected-note {{requested here}}
// expected-error@any:* {{binding value of type 'const TestType2' to reference to type 'TestType2' drops 'const' qualifier}}
- // expected-error@any:* {{static_assert failed "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
+ // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
any_cast<TestType2 &>(static_cast<any const&&>(a)); // expected-note {{requested here}}
// expected-error@any:* {{cannot cast from lvalue of type 'const TestType2' to rvalue reference type 'TestType2 &&'; types are not compatible}}
- // expected-error@any:* {{static_assert failed "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
+ // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
any_cast<TestType2 &&>(static_cast<any const&&>(a)); // expected-note {{requested here}}
}
diff --git a/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.fail.cpp b/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.fail.cpp
index ed4b96d..2d18cf4 100644
--- a/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.fail.cpp
+++ b/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.fail.cpp
@@ -42,17 +42,17 @@
int main() {
any a;
- // expected-error@any:* {{static_assert failed "ValueType is required to be an lvalue reference or a CopyConstructible type"}}
+ // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be an lvalue reference or a CopyConstructible type"}}
// expected-error@any:* {{static_cast from 'no_copy' to 'no_copy' uses deleted function}}
any_cast<no_copy>(static_cast<any&>(a)); // expected-note {{requested here}}
- // expected-error@any:* {{static_assert failed "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
+ // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
// expected-error@any:* {{static_cast from 'const no_copy' to 'no_copy' uses deleted function}}
any_cast<no_copy>(static_cast<any const&>(a)); // expected-note {{requested here}}
any_cast<no_copy>(static_cast<any &&>(a)); // OK
- // expected-error@any:* {{static_assert failed "ValueType is required to be an rvalue reference or a CopyConstructible type"}}
+ // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be an rvalue reference or a CopyConstructible type"}}
// expected-error@any:* {{static_cast from 'typename remove_reference<no_move &>::type' (aka 'no_move') to 'no_move' uses deleted function}}
any_cast<no_move>(static_cast<any &&>(a));
}
diff --git a/test/std/utilities/any/any.nonmembers/any.cast/reference_types.fail.cpp b/test/std/utilities/any/any.nonmembers/any.cast/reference_types.fail.cpp
index bbc1350..204c5c0 100644
--- a/test/std/utilities/any/any.nonmembers/any.cast/reference_types.fail.cpp
+++ b/test/std/utilities/any/any.nonmembers/any.cast/reference_types.fail.cpp
@@ -26,29 +26,29 @@
{
any a(1);
- // expected-error@any:* 1 {{static_assert failed "_ValueType may not be a reference."}}
+ // expected-error-re@any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
any_cast<int &>(&a); // expected-note {{requested here}}
- // expected-error@any:* 1 {{static_assert failed "_ValueType may not be a reference."}}
+ // expected-error-re@any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
any_cast<int &&>(&a); // expected-note {{requested here}}
- // expected-error@any:* 1 {{static_assert failed "_ValueType may not be a reference."}}
+ // expected-error-re@any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
any_cast<int const &>(&a); // expected-note {{requested here}}
- // expected-error@any:* 1 {{static_assert failed "_ValueType may not be a reference."}}
+ // expected-error-re@any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
any_cast<int const&&>(&a); // expected-note {{requested here}}
any const& a2 = a;
- // expected-error@any:* 1 {{static_assert failed "_ValueType may not be a reference."}}
+ // expected-error-re@any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
any_cast<int &>(&a2); // expected-note {{requested here}}
- // expected-error@any:* 1 {{static_assert failed "_ValueType may not be a reference."}}
+ // expected-error-re@any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
any_cast<int &&>(&a2); // expected-note {{requested here}}
- // expected-error@any:* 1 {{static_assert failed "_ValueType may not be a reference."}}
+ // expected-error-re@any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
any_cast<int const &>(&a2); // expected-note {{requested here}}
- // expected-error@any:* 1 {{static_assert failed "_ValueType may not be a reference."}}
+ // expected-error-re@any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
any_cast<int const &&>(&a2); // expected-note {{requested here}}
}
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 b85f439..fce826f 100644
--- a/test/std/utilities/function.objects/arithmetic.operations/transparent.pass.cpp
+++ b/test/std/utilities/function.objects/arithmetic.operations/transparent.pass.cpp
@@ -11,15 +11,15 @@
#include <functional>
#include <string>
-template <class _Tp>
+template <class T>
struct is_transparent
{
private:
- struct __two {char __lx; char __lxx;};
- template <class _Up> static __two __test(...);
- template <class _Up> static char __test(typename _Up::is_transparent* = 0);
+ struct two {char lx; char lxx;};
+ template <class U> static two test(...);
+ template <class U> static char test(typename U::is_transparent* = 0);
public:
- static const bool value = sizeof(__test<_Tp>(0)) == 1;
+ static const bool value = sizeof(test<T>(0)) == 1;
};
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 db7168c..bcd353e 100644
--- a/test/std/utilities/function.objects/bitwise.operations/transparent.pass.cpp
+++ b/test/std/utilities/function.objects/bitwise.operations/transparent.pass.cpp
@@ -11,15 +11,15 @@
#include <functional>
#include <string>
-template <class _Tp>
+template <class T>
struct is_transparent
{
private:
- struct __two {char __lx; char __lxx;};
- template <class _Up> static __two __test(...);
- template <class _Up> static char __test(typename _Up::is_transparent* = 0);
+ struct two {char lx; char lxx;};
+ template <class U> static two test(...);
+ template <class U> static char test(typename U::is_transparent* = 0);
public:
- static const bool value = sizeof(__test<_Tp>(0)) == 1;
+ static const bool value = sizeof(test<T>(0)) == 1;
};
diff --git a/test/std/utilities/function.objects/comparisons/transparent.pass.cpp b/test/std/utilities/function.objects/comparisons/transparent.pass.cpp
index f353fe7..ebae262 100644
--- a/test/std/utilities/function.objects/comparisons/transparent.pass.cpp
+++ b/test/std/utilities/function.objects/comparisons/transparent.pass.cpp
@@ -11,15 +11,15 @@
#include <functional>
#include <string>
-template <class _Tp>
+template <class T>
struct is_transparent
{
private:
- struct __two {char __lx; char __lxx;};
- template <class _Up> static __two __test(...);
- template <class _Up> static char __test(typename _Up::is_transparent* = 0);
+ struct two {char lx; char lxx;};
+ template <class U> static two test(...);
+ template <class U> static char test(typename U::is_transparent* = 0);
public:
- static const bool value = sizeof(__test<_Tp>(0)) == 1;
+ static const bool value = sizeof(test<T>(0)) == 1;
};
diff --git a/test/std/utilities/function.objects/func.invoke/invoke_feature_test_macro.pass.cpp b/test/std/utilities/function.objects/func.invoke/invoke_feature_test_macro.pass.cpp
index aaac984..9c3f242 100644
--- a/test/std/utilities/function.objects/func.invoke/invoke_feature_test_macro.pass.cpp
+++ b/test/std/utilities/function.objects/func.invoke/invoke_feature_test_macro.pass.cpp
@@ -36,4 +36,4 @@
#if defined(__cpp_lib_invoke)
assert(std::invoke(foo, 101) == 42);
#endif
-}
\ No newline at end of file
+}
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
index aa8eb39..1543f3d 100644
--- 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
@@ -587,7 +587,7 @@
}
void test_lwg2767() {
- // See http://wg21.link/LWG2767
+ // See https://cplusplus.github.io/LWG/lwg-defects.html#2767
struct Abstract { virtual void f() const = 0; };
struct Derived : public Abstract { void f() const {} };
struct F { bool operator()(Abstract&&) { return false; } };
diff --git a/test/std/utilities/function.objects/func.require/binary_function.pass.cpp b/test/std/utilities/function.objects/func.require/binary_function.pass.cpp
index fa7afb2..9346319 100644
--- a/test/std/utilities/function.objects/func.require/binary_function.pass.cpp
+++ b/test/std/utilities/function.objects/func.require/binary_function.pass.cpp
@@ -8,6 +8,8 @@
//===----------------------------------------------------------------------===//
// <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
+// binary_function was removed in C++17
// binary_function
diff --git a/test/std/utilities/function.objects/func.require/unary_function.pass.cpp b/test/std/utilities/function.objects/func.require/unary_function.pass.cpp
index f14b2d3..40a9d48 100644
--- a/test/std/utilities/function.objects/func.require/unary_function.pass.cpp
+++ b/test/std/utilities/function.objects/func.require/unary_function.pass.cpp
@@ -8,6 +8,8 @@
//===----------------------------------------------------------------------===//
// <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
+// unary_function was removed in C++17
// unary_function
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.pass.cpp
index 812f6fc..7d3a5de 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.pass.cpp
@@ -8,7 +8,6 @@
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
-// REQUIRES: c++11 || c++14
// <functional>
@@ -25,5 +24,7 @@
int main() {
S s( [](){} );
S f1( s );
+#if TEST_STD_VER <= 14
S f2(std::allocator_arg, std::allocator<int>{}, s);
+#endif
}
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_incomplete.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_incomplete.pass.cpp
index c8f4178..75e2eca 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_incomplete.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_incomplete.pass.cpp
@@ -16,6 +16,7 @@
// Allow incomplete argument types in the __is_callable check
#include <functional>
+#include <cassert>
struct X{
typedef std::function<void(X&)> callback_type;
@@ -24,6 +25,40 @@
callback_type _cb;
};
-int main()
+struct IncompleteReturnType {
+ std::function<IncompleteReturnType ()> fn;
+};
+
+
+int called = 0;
+IncompleteReturnType test_fn() {
+ ++called;
+ IncompleteReturnType I;
+ return I;
+}
+
+// See llvm.org/PR34298
+void test_pr34298()
{
+ static_assert(std::is_copy_constructible<IncompleteReturnType>::value, "");
+ static_assert(std::is_copy_assignable<IncompleteReturnType>::value, "");
+ {
+ IncompleteReturnType X;
+ X.fn = test_fn;
+ const IncompleteReturnType& CX = X;
+ IncompleteReturnType X2 = CX;
+ assert(X2.fn);
+ assert(called == 0);
+ X2.fn();
+ assert(called == 1);
+ }
+ {
+ IncompleteReturnType Empty;
+ IncompleteReturnType X2 = Empty;
+ assert(!X2.fn);
+ }
+}
+
+int main() {
+ test_pr34298();
}
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.fail.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.fail.cpp
index 24f7fce..b231534 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.fail.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.fail.cpp
@@ -25,5 +25,5 @@
int main()
{
- std::function<void(int)> f(std::allocator_arg, std::allocator<int>(), foo);
+ std::function<void(int)> f(std::allocator_arg, std::allocator<int>(), foo);
}
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp
index 4c1a1ca..8a2a12e 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp
@@ -8,7 +8,7 @@
//===----------------------------------------------------------------------===//
// <functional>
-// REQUIRES: c++98 || c++03 || c++11 ||c++14
+// REQUIRES: c++98 || c++03 || c++11 || c++14
// class function<R(ArgTypes...)>
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.fail.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.fail.cpp
index 9967457..2e4633b 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.fail.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.fail.cpp
@@ -24,7 +24,7 @@
int main()
{
- typedef std::function<void(int)> F;
- F f1;
- F f2(std::allocator_arg, std::allocator<int>(), f1);
+ typedef std::function<void(int)> F;
+ F f1;
+ F f2(std::allocator_arg, std::allocator<int>(), f1);
}
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_move.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_move.pass.cpp
index 7516b2e..faf4f11 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_move.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_move.pass.cpp
@@ -12,7 +12,7 @@
// class function<R(ArgTypes...)>
// function(const function& f);
-// function(const function&& f);
+// function(function&& f);
#include <functional>
#include <memory>
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 00e513e..d64c02f 100644
--- a/test/std/utilities/function.objects/logical.operations/transparent.pass.cpp
+++ b/test/std/utilities/function.objects/logical.operations/transparent.pass.cpp
@@ -11,15 +11,15 @@
#include <functional>
#include <string>
-template <class _Tp>
+template <class T>
struct is_transparent
{
private:
- struct __two {char __lx; char __lxx;};
- template <class _Up> static __two __test(...);
- template <class _Up> static char __test(typename _Up::is_transparent* = 0);
+ struct two {char lx; char lxx;};
+ template <class U> static two test(...);
+ template <class U> static char test(typename U::is_transparent* = 0);
public:
- static const bool value = sizeof(__test<_Tp>(0)) == 1;
+ static const bool value = sizeof(test<T>(0)) == 1;
};
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.access/conversion.pass.cpp b/test/std/utilities/function.objects/refwrap/refwrap.access/conversion.pass.cpp
index df0b55a..fede253 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.access/conversion.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.access/conversion.pass.cpp
@@ -17,7 +17,6 @@
#include <cassert>
class functor1
- : public std::unary_function<int, char>
{
};
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.assign/copy_assign.pass.cpp b/test/std/utilities/function.objects/refwrap/refwrap.assign/copy_assign.pass.cpp
index 122716a..ba3c71e 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.assign/copy_assign.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.assign/copy_assign.pass.cpp
@@ -17,7 +17,6 @@
#include <cassert>
class functor1
- : public std::unary_function<int, char>
{
};
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.const/copy_ctor.pass.cpp b/test/std/utilities/function.objects/refwrap/refwrap.const/copy_ctor.pass.cpp
index 721a442..d9f05b4 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.const/copy_ctor.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.const/copy_ctor.pass.cpp
@@ -17,7 +17,6 @@
#include <cassert>
class functor1
- : public std::unary_function<int, char>
{
};
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.pass.cpp b/test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.pass.cpp
index 564a3f7..d0dabd2 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.pass.cpp
@@ -17,7 +17,6 @@
#include <cassert>
class functor1
- : public std::unary_function<int, char>
{
};
diff --git a/test/std/utilities/function.objects/refwrap/weak_result.pass.cpp b/test/std/utilities/function.objects/refwrap/weak_result.pass.cpp
index 609094d..7ce4c84 100644
--- a/test/std/utilities/function.objects/refwrap/weak_result.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/weak_result.pass.cpp
@@ -16,27 +16,42 @@
#include <functional>
#include <type_traits>
+template <class Arg, class Result>
+struct my_unary_function
+{ // std::unary_function was removed in C++17
+ typedef Arg argument_type;
+ typedef Result result_type;
+};
+
+template <class Arg1, class Arg2, class Result>
+struct my_binary_function
+{ // std::binary_function was removed in C++17
+ typedef Arg1 first_argument_type;
+ typedef Arg2 second_argument_type;
+ typedef Result result_type;
+};
+
class functor1
- : public std::unary_function<int, char>
+ : public my_unary_function<int, char>
{
};
class functor2
- : public std::binary_function<char, int, double>
+ : public my_binary_function<char, int, double>
{
};
class functor3
- : public std::unary_function<char, int>,
- public std::binary_function<char, int, double>
+ : public my_unary_function<char, int>,
+ public my_binary_function<char, int, double>
{
public:
typedef float result_type;
};
class functor4
- : public std::unary_function<char, int>,
- public std::binary_function<char, int, double>
+ : public my_unary_function<char, int>,
+ public my_binary_function<char, int, double>
{
public:
};
diff --git a/test/std/utilities/function.objects/unord.hash/non_enum.pass.cpp b/test/std/utilities/function.objects/unord.hash/non_enum.pass.cpp
index ed173f2..72011f4 100644
--- a/test/std/utilities/function.objects/unord.hash/non_enum.pass.cpp
+++ b/test/std/utilities/function.objects/unord.hash/non_enum.pass.cpp
@@ -13,7 +13,7 @@
// Hashing a struct w/o a defined hash should *not* fail, but it should
// create a type that is not constructible and not callable.
-// See also: http://cplusplus.github.io/LWG/lwg-active.html#2543
+// See also: https://cplusplus.github.io/LWG/lwg-defects.html#2543
#include <functional>
#include <cassert>
diff --git a/test/std/utilities/function.objects/unord.hash/pointer.pass.cpp b/test/std/utilities/function.objects/unord.hash/pointer.pass.cpp
index 36280a3..f1c56ae 100644
--- a/test/std/utilities/function.objects/unord.hash/pointer.pass.cpp
+++ b/test/std/utilities/function.objects/unord.hash/pointer.pass.cpp
@@ -41,7 +41,7 @@
assert(h(&i) != h(&j));
}
-// can't hash nullptr_t until c++17
+// can't hash nullptr_t until C++17
void test_nullptr()
{
#if TEST_STD_VER > 14
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.pass.cpp
index ab8179c..292d68d 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.pass.cpp
@@ -20,6 +20,8 @@
#include <cstdint>
#include <cassert>
+#include "incomplete_type_helper.h"
+
template <class T>
struct A
{
@@ -34,6 +36,14 @@
int main()
{
+ {
A<int> a;
assert(std::allocator_traits<A<int> >::allocate(a, 10) == reinterpret_cast<int*>(static_cast<std::uintptr_t>(0xDEADBEEF)));
+ }
+ {
+ typedef IncompleteHolder* VT;
+ typedef A<VT> Alloc;
+ Alloc a;
+ assert(std::allocator_traits<Alloc >::allocate(a, 10) == reinterpret_cast<VT*>(static_cast<std::uintptr_t>(0xDEADBEEF)));
+ }
}
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate_hint.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate_hint.pass.cpp
index 8082842..90a9154 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate_hint.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate_hint.pass.cpp
@@ -21,6 +21,7 @@
#include <cassert>
#include "test_macros.h"
+#include "incomplete_type_helper.h"
template <class T>
struct A
@@ -52,12 +53,29 @@
}
};
+
int main()
{
#if TEST_STD_VER >= 11
+ {
A<int> a;
assert(std::allocator_traits<A<int> >::allocate(a, 10, nullptr) == reinterpret_cast<int*>(static_cast<std::uintptr_t>(0xDEADBEEF)));
+ }
+ {
+ typedef IncompleteHolder* VT;
+ typedef A<VT> Alloc;
+ Alloc a;
+ assert(std::allocator_traits<Alloc >::allocate(a, 10, nullptr) == reinterpret_cast<VT*>(static_cast<std::uintptr_t>(0xDEADBEEF)));
+ }
#endif
+ {
B<int> b;
assert(std::allocator_traits<B<int> >::allocate(b, 11, nullptr) == reinterpret_cast<int*>(static_cast<std::uintptr_t>(0xFEADBEEF)));
+ }
+ {
+ typedef IncompleteHolder* VT;
+ typedef B<VT> Alloc;
+ Alloc b;
+ assert(std::allocator_traits<Alloc >::allocate(b, 11, nullptr) == reinterpret_cast<VT*>(static_cast<std::uintptr_t>(0xFEADBEEF)));
+ }
}
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.members/construct.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.members/construct.pass.cpp
index 46075f6..e4aceff 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.members/construct.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.members/construct.pass.cpp
@@ -23,6 +23,7 @@
#include <cassert>
#include "test_macros.h"
+#include "incomplete_type_helper.h"
template <class T>
struct A
@@ -107,6 +108,13 @@
std::allocator_traits<A<int> >::construct(a, (A2*)&a2, 'd', 5);
assert(A2::count == 1);
}
+ {
+ typedef IncompleteHolder* VT;
+ typedef A<VT> Alloc;
+ Alloc a;
+ std::aligned_storage<sizeof(VT)>::type store;
+ std::allocator_traits<Alloc>::construct(a, (VT*)&store, nullptr);
+ }
#if TEST_STD_VER >= 11
{
A0::count = 0;
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.members/deallocate.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.members/deallocate.pass.cpp
index 8176d8b..ecb67ad 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.members/deallocate.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.members/deallocate.pass.cpp
@@ -20,6 +20,8 @@
#include <cstdint>
#include <cassert>
+#include "incomplete_type_helper.h"
+
int called = 0;
template <class T>
@@ -37,7 +39,17 @@
int main()
{
+ {
A<int> a;
std::allocator_traits<A<int> >::deallocate(a, reinterpret_cast<int*>(static_cast<std::uintptr_t>(0xDEADBEEF)), 10);
assert(called == 1);
+ }
+ called = 0;
+ {
+ typedef IncompleteHolder* VT;
+ typedef A<VT> Alloc;
+ Alloc a;
+ std::allocator_traits<Alloc >::deallocate(a, reinterpret_cast<VT*>(static_cast<std::uintptr_t>(0xDEADBEEF)), 10);
+ assert(called == 1);
+ }
}
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.members/destroy.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.members/destroy.pass.cpp
index 2ee64b8..1a81287 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.members/destroy.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.members/destroy.pass.cpp
@@ -23,6 +23,7 @@
#include <cassert>
#include "test_macros.h"
+#include "incomplete_type_helper.h"
template <class T>
struct A
@@ -65,6 +66,13 @@
std::allocator_traits<A<int> >::destroy(a, (A0*)&a0);
assert(A0::count == 1);
}
+ {
+ typedef IncompleteHolder* VT;
+ typedef A<VT> Alloc;
+ Alloc a;
+ std::aligned_storage<sizeof(VT)>::type store;
+ std::allocator_traits<Alloc>::destroy(a, (VT*)&store);
+ }
#if TEST_STD_VER >= 11
{
A0::count = 0;
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.members/incomplete_type_helper.h b/test/std/utilities/memory/allocator.traits/allocator.traits.members/incomplete_type_helper.h
new file mode 100644
index 0000000..7662338
--- /dev/null
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.members/incomplete_type_helper.h
@@ -0,0 +1,14 @@
+#ifndef TEST_INCOMPLETE_TYPE_HELPER_H
+#define TEST_INCOMPLETE_TYPE_HELPER_H
+
+#include "min_allocator.h"
+
+namespace NS {
+ struct Incomplete;
+}
+
+template <class T> struct Holder { T value; };
+
+typedef Holder<NS::Incomplete> IncompleteHolder;
+
+#endif
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 d2c9a98..12c0d02 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
@@ -22,6 +22,7 @@
#include <cassert>
#include "test_macros.h"
+#include "incomplete_type_helper.h"
template <class T>
struct A
@@ -51,6 +52,12 @@
const B<int> b = {};
assert(std::allocator_traits<B<int> >::max_size(b) == 100);
}
+ {
+ typedef IncompleteHolder* VT;
+ typedef B<VT> Alloc;
+ Alloc a;
+ assert(std::allocator_traits<Alloc >::max_size(a) == 100);
+ }
#if TEST_STD_VER >= 11
{
A<int> a;
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.members/select_on_container_copy_construction.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.members/select_on_container_copy_construction.pass.cpp
index 2e97030..8355db1 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.members/select_on_container_copy_construction.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.members/select_on_container_copy_construction.pass.cpp
@@ -23,6 +23,7 @@
#include <cassert>
#include "test_macros.h"
+#include "incomplete_type_helper.h"
template <class T>
struct A
@@ -57,6 +58,12 @@
const A<int> a(0);
assert(std::allocator_traits<A<int> >::select_on_container_copy_construction(a).id == 0);
}
+ {
+ typedef IncompleteHolder* VT;
+ typedef A<VT> Alloc;
+ Alloc a;
+ assert(std::allocator_traits<Alloc>::select_on_container_copy_construction(a).id == 0);
+ }
#if TEST_STD_VER >= 11
{
B<int> b;
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.types/is_always_equal.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.types/is_always_equal.pass.cpp
index 31a0f17..7f7b155 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.types/is_always_equal.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.types/is_always_equal.pass.cpp
@@ -37,7 +37,7 @@
struct C
{
typedef T value_type;
- int not_empty_; // some random member variable
+ int not_empty_; // some random member variable
};
int main()
diff --git a/test/std/utilities/memory/default.allocator/allocator.members/allocate.pass.cpp b/test/std/utilities/memory/default.allocator/allocator.members/allocate.pass.cpp
index 253515e..f2cf9f2 100644
--- a/test/std/utilities/memory/default.allocator/allocator.members/allocate.pass.cpp
+++ b/test/std/utilities/memory/default.allocator/allocator.members/allocate.pass.cpp
@@ -29,11 +29,12 @@
int main()
{
+ globalMemCounter.reset();
std::allocator<A> a;
assert(globalMemCounter.checkOutstandingNewEq(0));
assert(A_constructed == 0);
globalMemCounter.last_new_size = 0;
- A* ap = a.allocate(3);
+ A* volatile ap = a.allocate(3);
assert(globalMemCounter.checkOutstandingNewEq(1));
assert(globalMemCounter.checkLastNewSizeEq(3 * sizeof(int)));
assert(A_constructed == 0);
@@ -42,7 +43,7 @@
assert(A_constructed == 0);
globalMemCounter.last_new_size = 0;
- A* ap2 = a.allocate(3, (const void*)5);
+ A* volatile ap2 = a.allocate(3, (const void*)5);
assert(globalMemCounter.checkOutstandingNewEq(1));
assert(globalMemCounter.checkLastNewSizeEq(3 * sizeof(int)));
assert(A_constructed == 0);
diff --git a/test/std/utilities/memory/specialized.algorithms/specialized.addressof/addressof.temp.fail.cpp b/test/std/utilities/memory/specialized.algorithms/specialized.addressof/addressof.temp.fail.cpp
index 81f49ea..3ff32df 100644
--- a/test/std/utilities/memory/specialized.algorithms/specialized.addressof/addressof.temp.fail.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/specialized.addressof/addressof.temp.fail.cpp
@@ -19,7 +19,7 @@
int main()
{
#if TEST_STD_VER > 14
- const int *p = std::addressof<const int>(0);
+ const int *p = std::addressof<const int>(0);
#else
#error
#endif
diff --git a/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct_n.pass.cpp b/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct_n.pass.cpp
index ad6a515..319df22 100644
--- a/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct_n.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct_n.pass.cpp
@@ -112,4 +112,4 @@
{
test_counted();
test_value_initialized();
-}
\ No newline at end of file
+}
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 1829dff..2f387a4 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
@@ -71,7 +71,7 @@
std::uninitialized_copy(b, b+2, bp);
for (int i = 0; i < 2; ++i)
assert(bp[i].data_ == 1);
- assert(B::population_ == N + 2);
+ assert(B::population_ == N + 2);
}
{
diff --git a/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move.pass.cpp b/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move.pass.cpp
index 6c53525..d914129 100644
--- a/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move.pass.cpp
@@ -111,4 +111,4 @@
int main() {
test_counted();
test_ctor_throws();
-}
\ No newline at end of file
+}
diff --git a/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move_n.pass.cpp b/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move_n.pass.cpp
index 4175c6b..4083bc3 100644
--- a/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move_n.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move_n.pass.cpp
@@ -114,4 +114,4 @@
{
test_counted();
test_ctor_throws();
-}
\ No newline at end of file
+}
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 eb0d0a9..30a4933 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
@@ -41,7 +41,7 @@
struct Foo : virtual public std::enable_shared_from_this<Foo>
{
- virtual ~Foo() {}
+ virtual ~Foo() {}
};
struct Bar : public Foo {
@@ -80,12 +80,11 @@
}
{
typedef std::shared_ptr<PrivateBase> APtr;
- typedef std::weak_ptr<PrivateBase> WeakAPtr;
APtr a1 = std::make_shared<PrivateBase>();
assert(a1.use_count() == 1);
}
// Test LWG issue 2529. Only reset '__weak_ptr_' when it's already expired.
- // http://cplusplus.github.io/LWG/lwg-active.html#2529.
+ // https://cplusplus.github.io/LWG/lwg-defects.html#2529
// Test two different ways:
// * Using 'weak_from_this().expired()' in C++17.
// * Using 'shared_from_this()' in all dialects.
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 501844a..117dd97 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
@@ -74,14 +74,14 @@
assert(!cs(p2, p1));
assert(cs(p1 ,p3) || cs(p3, p1));
assert(cs(p3, p1) == cs(p3, p2));
- ASSERT_NOEXCEPT(cs(p1, p1));
+ ASSERT_NOEXCEPT(cs(p1, p1));
assert(!cs(p1, w2));
assert(!cs(p2, w1));
assert(cs(p1, w3) || cs(p3, w1));
assert(cs(p3, w1) == cs(p3, w2));
- ASSERT_NOEXCEPT(cs(p1, w1));
- ASSERT_NOEXCEPT(cs(w1, p1));
+ ASSERT_NOEXCEPT(cs(p1, w1));
+ ASSERT_NOEXCEPT(cs(w1, p1));
}
{
typedef std::owner_less<std::weak_ptr<int> > CS;
@@ -95,14 +95,14 @@
assert(!cs(w2, w1));
assert(cs(w1, w3) || cs(w3, w1));
assert(cs(w3, w1) == cs(w3, w2));
- ASSERT_NOEXCEPT(cs(w1, w1));
+ ASSERT_NOEXCEPT(cs(w1, w1));
assert(!cs(w1, p2));
assert(!cs(w2, p1));
assert(cs(w1, p3) || cs(w3, p1));
assert(cs(w3, p1) == cs(w3, p2));
- ASSERT_NOEXCEPT(cs(w1, p1));
- ASSERT_NOEXCEPT(cs(p1, w1));
+ ASSERT_NOEXCEPT(cs(w1, p1));
+ ASSERT_NOEXCEPT(cs(p1, w1));
}
#if TEST_STD_VER > 14
{
@@ -117,10 +117,10 @@
cmp(sp1, sp3);
cmp(wp1, sp1);
cmp(wp1, wp1);
- ASSERT_NOEXCEPT(cmp(sp1, sp1));
- ASSERT_NOEXCEPT(cmp(sp1, wp1));
- ASSERT_NOEXCEPT(cmp(wp1, sp1));
- ASSERT_NOEXCEPT(cmp(wp1, wp1));
+ ASSERT_NOEXCEPT(cmp(sp1, sp1));
+ ASSERT_NOEXCEPT(cmp(sp1, wp1));
+ ASSERT_NOEXCEPT(cmp(wp1, sp1));
+ ASSERT_NOEXCEPT(cmp(wp1, wp1));
}
{
// test heterogeneous lookups
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_shared_ptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_shared_ptr.pass.cpp
index 458f8a1..23df0d8 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_shared_ptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_shared_ptr.pass.cpp
@@ -29,6 +29,5 @@
assert(!w2.owner_before(p1));
assert(w1.owner_before(p3) || w3.owner_before(p1));
assert(w3.owner_before(p1) == w3.owner_before(p2));
-// change to 'ASSERT_NOEXCEPT' when LWG2942 is adopted
- LIBCPP_ASSERT_NOEXCEPT(w1.owner_before(p2));
+ ASSERT_NOEXCEPT(w1.owner_before(p2));
}
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_weak_ptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_weak_ptr.pass.cpp
index 5cd171a..a38bf67 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_weak_ptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_weak_ptr.pass.cpp
@@ -29,6 +29,5 @@
assert(!w2.owner_before(w1));
assert(w1.owner_before(w3) || w3.owner_before(w1));
assert(w3.owner_before(w1) == w3.owner_before(w2));
-// change to 'ASSERT_NOEXCEPT' when LWG2942 is adopted
- LIBCPP_ASSERT_NOEXCEPT(w1.owner_before(w2));
+ ASSERT_NOEXCEPT(w1.owner_before(w2));
}
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/decay.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/decay.pass.cpp
index 4f45a03..c0aece7 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/decay.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/decay.pass.cpp
@@ -34,9 +34,9 @@
test_decay<const int[3], const int*>();
test_decay<void(), void (*)()>();
#if TEST_STD_VER > 11
- test_decay<int(int) const, int(int) const>();
- test_decay<int(int) volatile, int(int) volatile>();
- test_decay<int(int) &, int(int) &>();
- test_decay<int(int) &&, int(int) &&>();
+ test_decay<int(int) const, int(int) const>();
+ test_decay<int(int) volatile, int(int) volatile>();
+ test_decay<int(int) &, int(int) &>();
+ test_decay<int(int) &&, int(int) &&>();
#endif
}
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 4e875fa..23d5176 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
@@ -77,11 +77,11 @@
int main()
{
- test_is_function<void(void)>();
- test_is_function<int(int)>();
- test_is_function<int(int, double)>();
- test_is_function<int(Abstract *)>();
- test_is_function<void(...)>();
+ test_is_function<void(void)>();
+ test_is_function<int(int)>();
+ 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>();
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 f776196..052b0b9 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
@@ -91,11 +91,11 @@
test_is_fundamental<unsigned char>();
test_is_fundamental<wchar_t>();
test_is_fundamental<double>();
- test_is_fundamental<float>();
- test_is_fundamental<double>();
- test_is_fundamental<long double>();
- test_is_fundamental<char16_t>();
- test_is_fundamental<char32_t>();
+ test_is_fundamental<float>();
+ test_is_fundamental<double>();
+ 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[]>();
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 3955d4b..8d63a23 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
@@ -81,5 +81,5 @@
test_is_not_assignable<int(), int> ();
// pointer to incomplete template type
- test_is_assignable<X<D>*&, X<D>*> ();
+ test_is_assignable<X<D>*&, X<D>*> ();
}
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 9d2ec5e..1f7c32a 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
@@ -9,7 +9,7 @@
// type_traits
// XFAIL: apple-clang-6.0
-// The Apple-6 compiler gets is_constructible<void ()> wrong.
+// The Apple-6 compiler gets is_constructible<void ()> wrong.
// template <class T, class... Args>
// struct is_constructible;
diff --git a/test/std/utilities/optional/optional.nullopt/not_brace_initializable.fail.cpp b/test/std/utilities/optional/optional.nullopt/not_brace_initializable.fail.cpp
deleted file mode 100644
index 86da505..0000000
--- a/test/std/utilities/optional/optional.nullopt/not_brace_initializable.fail.cpp
+++ /dev/null
@@ -1,25 +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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11, c++14
-// <optional>
-
-// struct nullopt_t{see below};
-
-#include <optional>
-
-using std::optional;
-using std::nullopt_t;
-
-int main()
-{
- // I roughly interpret LWG2736 as "it shall not be possible to copy-list-initialize nullopt_t with an
- // empty braced-init-list."
- nullopt_t foo = {};
-}
diff --git a/test/std/utilities/optional/optional.nullopt/nullopt_t.fail.cpp b/test/std/utilities/optional/optional.nullopt/nullopt_t.fail.cpp
index f9ea7b4..c97bebe 100644
--- a/test/std/utilities/optional/optional.nullopt/nullopt_t.fail.cpp
+++ b/test/std/utilities/optional/optional.nullopt/nullopt_t.fail.cpp
@@ -11,17 +11,15 @@
// <optional>
// struct nullopt_t{see below};
-// constexpr nullopt_t nullopt(unspecified);
+// inline constexpr nullopt_t nullopt(unspecified);
// [optional.nullopt]/2:
-// Type nullopt_t shall not have a default constructor or an initializer-list constructor.
-// It shall not be an aggregate and shall be a literal type.
-// Constant nullopt shall be initialized with an argument of literal type.
+// Type nullopt_t shall not have a default constructor or an initializer-list
+// constructor, and shall not be an aggregate.
#include <optional>
-#include "test_macros.h"
int main()
{
- std::nullopt_t n = {};
+ std::nullopt_t n = {};
}
diff --git a/test/std/utilities/optional/optional.nullopt/nullopt_t.pass.cpp b/test/std/utilities/optional/optional.nullopt/nullopt_t.pass.cpp
index 9b752a6..247fce5 100644
--- a/test/std/utilities/optional/optional.nullopt/nullopt_t.pass.cpp
+++ b/test/std/utilities/optional/optional.nullopt/nullopt_t.pass.cpp
@@ -11,33 +11,30 @@
// <optional>
// struct nullopt_t{see below};
-// constexpr nullopt_t nullopt(unspecified);
+// inline constexpr nullopt_t nullopt(unspecified);
// [optional.nullopt]/2:
-// Type nullopt_t shall not have a default constructor or an initializer-list constructor.
-// It shall not be an aggregate and shall be a literal type.
-// Constant nullopt shall be initialized with an argument of literal type.
+// Type nullopt_t shall not have a default constructor or an initializer-list
+// constructor, and shall not be an aggregate.
#include <optional>
#include <type_traits>
-using std::optional;
using std::nullopt_t;
using std::nullopt;
-constexpr
-int
-test(const nullopt_t&)
+constexpr bool test()
{
- return 3;
+ nullopt_t foo{nullopt};
+ (void)foo;
+ return true;
}
int main()
{
- 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(std::is_empty_v<nullopt_t>);
+ static_assert(!std::is_default_constructible_v<nullopt_t>);
- static_assert(test(nullopt) == 3, "");
+ static_assert(std::is_same_v<const nullopt_t, decltype(nullopt)>);
+ static_assert(test());
}
diff --git a/test/std/utilities/optional/optional.object/optional.object.assign/move.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.assign/move.pass.cpp
index 3ba261b..ed8b433 100644
--- a/test/std/utilities/optional/optional.object/optional.object.assign/move.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.assign/move.pass.cpp
@@ -147,27 +147,27 @@
}
{
struct ThrowsMove {
- ThrowsMove() noexcept {}
- ThrowsMove(ThrowsMove const&) noexcept {}
- ThrowsMove(ThrowsMove &&) noexcept(false) {}
- ThrowsMove& operator=(ThrowsMove const&) noexcept { return *this; }
- ThrowsMove& operator=(ThrowsMove &&) noexcept { return *this; }
+ ThrowsMove() noexcept {}
+ ThrowsMove(ThrowsMove const&) noexcept {}
+ ThrowsMove(ThrowsMove &&) noexcept(false) {}
+ ThrowsMove& operator=(ThrowsMove const&) noexcept { return *this; }
+ ThrowsMove& operator=(ThrowsMove &&) noexcept { return *this; }
};
static_assert(!std::is_nothrow_move_assignable<optional<ThrowsMove>>::value, "");
struct ThrowsMoveAssign {
- ThrowsMoveAssign() noexcept {}
- ThrowsMoveAssign(ThrowsMoveAssign const&) noexcept {}
- ThrowsMoveAssign(ThrowsMoveAssign &&) noexcept {}
- ThrowsMoveAssign& operator=(ThrowsMoveAssign const&) noexcept { return *this; }
- ThrowsMoveAssign& operator=(ThrowsMoveAssign &&) noexcept(false) { return *this; }
+ ThrowsMoveAssign() noexcept {}
+ ThrowsMoveAssign(ThrowsMoveAssign const&) noexcept {}
+ ThrowsMoveAssign(ThrowsMoveAssign &&) noexcept {}
+ ThrowsMoveAssign& operator=(ThrowsMoveAssign const&) noexcept { return *this; }
+ ThrowsMoveAssign& operator=(ThrowsMoveAssign &&) noexcept(false) { return *this; }
};
static_assert(!std::is_nothrow_move_assignable<optional<ThrowsMoveAssign>>::value, "");
struct NoThrowMove {
- NoThrowMove() noexcept(false) {}
- NoThrowMove(NoThrowMove const&) noexcept(false) {}
- NoThrowMove(NoThrowMove &&) noexcept {}
- NoThrowMove& operator=(NoThrowMove const&) noexcept { return *this; }
- NoThrowMove& operator=(NoThrowMove&&) noexcept { return *this; }
+ NoThrowMove() noexcept(false) {}
+ NoThrowMove(NoThrowMove const&) noexcept(false) {}
+ NoThrowMove(NoThrowMove &&) noexcept {}
+ NoThrowMove& operator=(NoThrowMove const&) noexcept { return *this; }
+ NoThrowMove& operator=(NoThrowMove&&) noexcept { return *this; }
};
static_assert(std::is_nothrow_move_assignable<optional<NoThrowMove>>::value, "");
}
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/copy.fail.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/copy.fail.cpp
index 3224c1b..77e411b 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/copy.fail.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/copy.fail.cpp
@@ -21,11 +21,11 @@
#include "test_macros.h"
struct S {
- constexpr S() : v_(0) {}
- S(int v) : v_(v) {}
- S(const S &rhs) : v_(rhs.v_) {} // make it not trivially copyable
- int v_;
- };
+ constexpr S() : v_(0) {}
+ S(int v) : v_(v) {}
+ S(const S &rhs) : v_(rhs.v_) {} // make it not trivially copyable
+ int v_;
+ };
int main()
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp
index 6b4283a..0f1fabd 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp
@@ -45,10 +45,10 @@
void test_throwing_ctor() {
#ifndef TEST_HAS_NO_EXCEPTIONS
struct Z {
- Z() : count(0) {}
- Z(Z const& o) : count(o.count + 1)
- { if (count == 2) throw 6; }
- int count;
+ Z() : count(0) {}
+ Z(Z const& o) : count(o.count + 1)
+ { if (count == 2) throw 6; }
+ int count;
};
const Z z;
const optional<Z> rhs(z);
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/move.fail.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/move.fail.cpp
index fb2e139..4e3991c 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/move.fail.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/move.fail.cpp
@@ -21,12 +21,12 @@
#include "test_macros.h"
struct S {
- constexpr S() : v_(0) {}
- S(int v) : v_(v) {}
- constexpr S(const S &rhs) : v_(rhs.v_) {} // not trivially moveable
- constexpr S(const S &&rhs) : v_(rhs.v_) {} // not trivially moveable
- int v_;
- };
+ constexpr S() : v_(0) {}
+ S(int v) : v_(v) {}
+ constexpr S(const S &rhs) : v_(rhs.v_) {} // not trivially moveable
+ constexpr S(const S &&rhs) : v_(rhs.v_) {} // not trivially moveable
+ int v_;
+ };
int main()
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
index 82acdd9..e73f374 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
@@ -55,10 +55,10 @@
void test_throwing_ctor() {
#ifndef TEST_HAS_NO_EXCEPTIONS
struct Z {
- Z() : count(0) {}
- Z(Z&& o) : count(o.count + 1)
- { if (count == 2) throw 6; }
- int count;
+ Z() : count(0) {}
+ Z(Z&& o) : count(o.count + 1)
+ { if (count == 2) throw 6; }
+ int count;
};
Z z;
optional<Z> rhs(std::move(z));
@@ -157,7 +157,7 @@
test<int>(3);
static_assert(constexpr_test<int>(), "" );
static_assert(constexpr_test<int>(3), "" );
-
+
{
optional<const int> o(42);
optional<const int> o2(std::move(o));
diff --git a/test/std/utilities/optional/optional.object/optional_requires_destructible_object.fail.cpp b/test/std/utilities/optional/optional.object/optional_requires_destructible_object.fail.cpp
index 8a2c77a..11ddcb7 100644
--- a/test/std/utilities/optional/optional.object/optional_requires_destructible_object.fail.cpp
+++ b/test/std/utilities/optional/optional.object/optional_requires_destructible_object.fail.cpp
@@ -26,22 +26,22 @@
{
using std::optional;
{
- // expected-error@optional:* 2 {{static_assert failed "instantiation of optional with a reference type is ill-formed}}
+ // expected-error-re@optional:* 2 {{static_assert failed{{.*}} "instantiation of optional with a reference type is ill-formed}}
optional<int&> opt1;
optional<int&&> opt2;
}
{
- // expected-error@optional:* {{static_assert failed "instantiation of optional with a non-destructible type is ill-formed"}}
+ // expected-error-re@optional:* {{static_assert failed{{.*}} "instantiation of optional with a non-destructible type is ill-formed"}}
optional<X> opt3;
}
{
- // expected-error@optional:* {{static_assert failed "instantiation of optional with a non-object type is undefined behavior"}}
- // expected-error@optional:* {{static_assert failed "instantiation of optional with a non-destructible type is ill-formed}}
+ // expected-error-re@optional:* {{static_assert failed{{.*}} "instantiation of optional with a non-object type is undefined behavior"}}
+ // expected-error-re@optional:* {{static_assert failed{{.*}} "instantiation of optional with a non-destructible type is ill-formed}}
optional<void()> opt4;
}
{
- // expected-error@optional:* {{static_assert failed "instantiation of optional with a non-object type is undefined behavior"}}
- // expected-error@optional:* {{static_assert failed "instantiation of optional with a non-destructible type is ill-formed}}
+ // expected-error-re@optional:* {{static_assert failed{{.*}} "instantiation of optional with a non-object type is undefined behavior"}}
+ // expected-error-re@optional:* {{static_assert failed{{.*}} "instantiation of optional with a non-destructible type is ill-formed}}
// expected-error@optional:* 1+ {{cannot form a reference to 'void'}}
optional<const void> opt4;
}
diff --git a/test/std/utilities/optional/optional.object/special_member_gen.pass.cpp b/test/std/utilities/optional/optional.object/special_member_gen.pass.cpp
index fdd0f15..0b9b6e7 100644
--- a/test/std/utilities/optional/optional.object/special_member_gen.pass.cpp
+++ b/test/std/utilities/optional/optional.object/special_member_gen.pass.cpp
@@ -33,10 +33,38 @@
"optional<T> is copy assignable if and only if T is both copy "
"constructible and copy assignable.");
static_assert(std::is_move_assignable_v<O> ==
- ((std::is_copy_constructible_v<T> && std::is_copy_assignable_v<T>) ||
- (std::is_move_constructible_v<T> && std::is_move_assignable_v<T>)),
- "optional<T> is move assignable if and only if T is both move assignable and "
- "move constructible, or both copy constructible and copy assignable.");
+ ((std::is_move_constructible_v<T> && std::is_move_assignable_v<T>) ||
+ (std::is_copy_constructible_v<T> && std::is_copy_assignable_v<T>)),
+ "optional<T> is move assignable if and only if T is both move constructible and "
+ "move assignable, or both copy constructible and copy assignable.");
+
+ // The following tests are for not-yet-standardized behavior (P0602):
+ static_assert(std::is_trivially_destructible_v<O> ==
+ std::is_trivially_destructible_v<T>,
+ "optional<T> is trivially destructible if and only if T is.");
+ static_assert(std::is_trivially_copy_constructible_v<O> ==
+ std::is_trivially_copy_constructible_v<T>,
+ "optional<T> is trivially copy constructible if and only if T is.");
+ static_assert(std::is_trivially_move_constructible_v<O> ==
+ std::is_trivially_move_constructible_v<T> ||
+ (!std::is_move_constructible_v<T> && std::is_trivially_copy_constructible_v<T>),
+ "optional<T> is trivially move constructible if T is trivially move constructible, "
+ "or if T is trivially copy constructible and is not move constructible.");
+ static_assert(std::is_trivially_copy_assignable_v<O> ==
+ (std::is_trivially_destructible_v<T> &&
+ std::is_trivially_copy_constructible_v<T> &&
+ std::is_trivially_copy_assignable_v<T>),
+ "optional<T> is trivially copy assignable if and only if T is trivially destructible, "
+ "trivially copy constructible, and trivially copy assignable.");
+ static_assert(std::is_trivially_move_assignable_v<O> ==
+ (std::is_trivially_destructible_v<T> &&
+ ((std::is_trivially_move_constructible_v<T> && std::is_trivially_move_assignable_v<T>) ||
+ ((!std::is_move_constructible_v<T> || !std::is_move_assignable_v<T>) &&
+ std::is_trivially_copy_constructible_v<T> && std::is_trivially_copy_assignable_v<T>))),
+ "optional<T> is trivially move assignable if T is trivially destructible, and either "
+ "(1) trivially move constructible and trivially move assignable, or "
+ "(2) not move constructible or not move assignable, and "
+ "trivially copy constructible and trivially copy assignable.");
};
template <class ...Args> static void sink(Args&&...) {}
diff --git a/test/std/utilities/optional/optional.syn/optional_includes_initializer_list.pass.cpp b/test/std/utilities/optional/optional.syn/optional_includes_initializer_list.pass.cpp
index 687625e..5790302 100644
--- a/test/std/utilities/optional/optional.syn/optional_includes_initializer_list.pass.cpp
+++ b/test/std/utilities/optional/optional.syn/optional_includes_initializer_list.pass.cpp
@@ -19,4 +19,5 @@
using std::optional;
std::initializer_list<int> list;
+ (void)list;
}
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.single.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.single.pass.cpp
index 4e2a6df..d747483 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.single.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.single.pass.cpp
@@ -14,7 +14,7 @@
// Test unique_ptr converting move ctor
-// NOTE: unique_ptr does not provide converting constructors in c++03
+// NOTE: unique_ptr does not provide converting constructors in C++03
// UNSUPPORTED: c++98, c++03
#include <memory>
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 24847dd..2f8a707 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
@@ -24,8 +24,8 @@
#include <chrono>
-template <class _Tp>
-void test(const _Tp &) {}
+template <class T>
+void test(const T &) {}
int main()
{
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 cdb38df..4458d6f 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
@@ -26,8 +26,8 @@
#include <chrono>
-template <class _Tp>
-void test(const _Tp &) {}
+template <class T>
+void test(const T &) {}
int main()
{
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 dfc08a3..deb4615 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
@@ -24,8 +24,8 @@
#include <chrono>
-template <class _Tp>
-void test(const _Tp &) {}
+template <class T>
+void test(const T &) {}
int main()
{
diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++.pass.cpp
index 702c38d..416a8db 100644
--- a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++.pass.cpp
@@ -11,7 +11,7 @@
// duration
-// constexpr duration& operator++(); // constexpr in c++17
+// constexpr duration& operator++(); // constexpr in C++17
#include <chrono>
#include <cassert>
diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++int.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++int.pass.cpp
index 49b8c76..deb4daa 100644
--- a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++int.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++int.pass.cpp
@@ -11,7 +11,7 @@
// duration
-// constexpr duration operator++(int); // constexpr in c++17
+// constexpr duration operator++(int); // constexpr in C++17
#include <chrono>
#include <cassert>
diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_+=.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_+=.pass.cpp
index bec8eff..b74011a 100644
--- a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_+=.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_+=.pass.cpp
@@ -11,7 +11,7 @@
// duration
-// constexpr duration& operator+=(const duration& d); // constexpr in c++17
+// constexpr duration& operator+=(const duration& d); // constexpr in C++17
#include <chrono>
#include <cassert>
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 d1b974c..811dfc0 100644
--- a/test/std/utilities/tuple/tuple.general/tuple.smartptr.pass.cpp
+++ b/test/std/utilities/tuple/tuple.general/tuple.smartptr.pass.cpp
@@ -29,5 +29,5 @@
}
// 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.
+ // See https://reviews.llvm.org/D21320 for more information.
}
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 06284df..fed27aa 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
@@ -147,6 +147,7 @@
#if TEST_STD_VER > 11
{
constexpr std::tuple<Empty> t0{Empty()};
+ (void)t0;
}
{
constexpr std::tuple<A, A> t(3, 2);
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 b262f3c..bf66da1 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
@@ -102,6 +102,8 @@
using T = NonDefaultConstructible<>;
T v(42);
std::tuple<T, T> t(v, v);
+ (void)t;
std::tuple<T, T> t2(42, 42);
+ (void)t2;
}
}
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/default.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/default.pass.cpp
index fa2f116..7319466 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/default.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/default.pass.cpp
@@ -49,6 +49,7 @@
{
{
std::tuple<> t;
+ (void)t;
}
{
std::tuple<int> t;
@@ -88,6 +89,7 @@
}
{
constexpr std::tuple<> t;
+ (void)t;
}
{
constexpr std::tuple<int> t;
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/dtor.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/dtor.pass.cpp
index d7b184f..b4fd2e2 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/dtor.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/dtor.pass.cpp
@@ -16,7 +16,7 @@
// ~tuple();
// C++17 added:
-// The destructor of tuple shall be a trivial destructor
+// The destructor of tuple shall be a trivial destructor
// if (is_trivially_destructible_v<Types> && ...) is true.
#include <tuple>
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/implicit_deduction_guides.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/implicit_deduction_guides.pass.cpp
index 7b9c061..85036b5 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/implicit_deduction_guides.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/implicit_deduction_guides.pass.cpp
@@ -15,10 +15,11 @@
// against libstdc++.
// XFAIL: gcc
-// <string>
+// <tuple>
-// Test that the constructors offered by std::basic_string are formulated
-// so they're compatible with implicit deduction guides.
+// Test that the constructors offered by std::tuple are formulated
+// so they're compatible with implicit deduction guides, or if that's not
+// possible that they provide explicit guides to make it work.
#include <tuple>
#include <memory>
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_structured_bindings.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_structured_bindings.pass.cpp
index aadbf3d..03fb78c 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_structured_bindings.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_structured_bindings.pass.cpp
@@ -64,18 +64,22 @@
void test_decomp_pair() {
typedef std::pair<int, double> T;
{
- T s{99, 42.1};
+ T s{99, 42.5};
auto [m1, m2] = s;
auto& [r1, r2] = s;
assert(m1 == 99);
+ assert(m2 == 42.5);
assert(&r1 == &std::get<0>(s));
+ assert(&r2 == &std::get<1>(s));
}
{
- T const s{99, 42.1};
+ T const s{99, 42.5};
auto [m1, m2] = s;
auto& [r1, r2] = s;
assert(m1 == 99);
+ assert(m2 == 42.5);
assert(&r1 == &std::get<0>(s));
+ assert(&r2 == &std::get<1>(s));
}
}
@@ -86,14 +90,22 @@
auto [m1, m2, m3] = s;
auto& [r1, r2, r3] = s;
assert(m1 == 99);
+ assert(m2 == 42);
+ assert(m3 == -1);
assert(&r1 == &std::get<0>(s));
+ assert(&r2 == &std::get<1>(s));
+ assert(&r3 == &std::get<2>(s));
}
{
T const s{{99, 42, -1}};
auto [m1, m2, m3] = s;
auto& [r1, r2, r3] = s;
assert(m1 == 99);
+ assert(m2 == 42);
+ assert(m3 == -1);
assert(&r1 == &std::get<0>(s));
+ assert(&r2 == &std::get<1>(s));
+ assert(&r3 == &std::get<2>(s));
}
}
diff --git a/test/std/utilities/utility/as_const/as_const.fail.cpp b/test/std/utilities/utility/as_const/as_const.fail.cpp
index 6334e14..c28957c 100644
--- a/test/std/utilities/utility/as_const/as_const.fail.cpp
+++ b/test/std/utilities/utility/as_const/as_const.fail.cpp
@@ -18,5 +18,5 @@
int main()
{
- std::as_const(S{});
+ std::as_const(S{});
}
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 7bb5849..268f2d1 100644
--- a/test/std/utilities/utility/as_const/as_const.pass.cpp
+++ b/test/std/utilities/utility/as_const/as_const.pass.cpp
@@ -37,10 +37,10 @@
int main()
{
- int i = 3;
- double d = 4.0;
- S s{2};
- test(i);
- test(d);
- test(s);
+ int i = 3;
+ double d = 4.0;
+ S s{2};
+ test(i);
+ test(d);
+ test(s);
}
diff --git a/test/std/utilities/utility/forward/forward.fail.cpp b/test/std/utilities/utility/forward/forward.fail.cpp
index a3bb890..c845216 100644
--- a/test/std/utilities/utility/forward/forward.fail.cpp
+++ b/test/std/utilities/utility/forward/forward.fail.cpp
@@ -25,7 +25,7 @@
#if TEST_STD_VER >= 11
{
std::forward<A&>(source()); // expected-note {{requested here}}
- // expected-error@type_traits:* 1 {{static_assert failed "can not forward an rvalue as an lvalue"}}
+ // expected-error-re@type_traits:* 1 {{static_assert failed{{.*}} "can not forward an rvalue as an lvalue"}}
}
#else
{
diff --git a/test/std/utilities/utility/pairs/pair.astuple/tuple_element.fail.cpp b/test/std/utilities/utility/pairs/pair.astuple/tuple_element.fail.cpp
new file mode 100644
index 0000000..4ca31f7
--- /dev/null
+++ b/test/std/utilities/utility/pairs/pair.astuple/tuple_element.fail.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <utility>
+
+// template <class T1, class T2> struct pair
+
+// tuple_element<I, pair<T1, T2> >::type
+
+#include <utility>
+
+int main()
+{
+ typedef std::pair<int, short> T;
+ std::tuple_element<2, T>::type foo; // expected-error@utility:* {{Index out of bounds in std::tuple_element<std::pair<T1, T2>>}}
+}
diff --git a/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp
index ade8130..715b655 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp
@@ -71,7 +71,7 @@
P1 p1(42, 101);
P2 p2(p1);
assert(p2.first == 42);
- assert(p2.second = 101);
+ assert(p2.second == 101);
}
{
test_pair_const<AllCtors, AllCtors>(); // copy construction
diff --git a/test/std/utilities/utility/pairs/pairs.pair/dtor.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/dtor.pass.cpp
index 83c55e7..b25099f 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/dtor.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/dtor.pass.cpp
@@ -16,7 +16,7 @@
// ~pair()
// C++17 added:
-// The destructor of pair shall be a trivial destructor
+// The destructor of pair shall be a trivial destructor
// if (is_trivially_destructible_v<T1> && is_trivially_destructible_v<T2>) is true.
diff --git a/test/std/utilities/utility/pairs/pairs.pair/implicit_deduction_guides.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/implicit_deduction_guides.pass.cpp
new file mode 100644
index 0000000..7933dd9
--- /dev/null
+++ b/test/std/utilities/utility/pairs/pairs.pair/implicit_deduction_guides.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, c++11, c++14
+// UNSUPPORTED: libcpp-no-deduction-guides
+
+// GCC's implementation of class template deduction is still immature and runs
+// into issues with libc++. However GCC accepts this code when compiling
+// against libstdc++.
+// XFAIL: gcc
+
+// <utility>
+
+// Test that the constructors offered by std::pair are formulated
+// so they're compatible with implicit deduction guides, or if that's not
+// possible that they provide explicit guides to make it work.
+
+#include <utility>
+#include <memory>
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+#include "archetypes.hpp"
+
+
+// Overloads
+// ---------------
+// (1) pair(const T1&, const T2&) -> pair<T1, T2>
+// (2) explicit pair(const T1&, const T2&) -> pair<T1, T2>
+// (3) pair(pair const& t) -> decltype(t)
+// (4) pair(pair&& t) -> decltype(t)
+// (5) pair(pair<U1, U2> const&) -> pair<U1, U2>
+// (6) explicit pair(pair<U1, U2> const&) -> pair<U1, U2>
+// (7) pair(pair<U1, U2> &&) -> pair<U1, U2>
+// (8) explicit pair(pair<U1, U2> &&) -> pair<U1, U2>
+int main()
+{
+ using E = ExplicitTestTypes::TestType;
+ static_assert(!std::is_convertible<E const&, E>::value, "");
+ { // Testing (1)
+ int const x = 42;
+ std::pair t1("abc", x);
+ ASSERT_SAME_TYPE(decltype(t1), std::pair<const char*, int>);
+ }
+ { // Testing (2)
+ std::pair p1(E{}, 42);
+ ASSERT_SAME_TYPE(decltype(p1), std::pair<E, int>);
+
+ const E t{};
+ std::pair p2(t, E{});
+ ASSERT_SAME_TYPE(decltype(p2), std::pair<E, E>);
+ }
+ { // Testing (3, 5)
+ std::pair<double, decltype(nullptr)> const p(0.0, nullptr);
+ std::pair p1(p);
+ ASSERT_SAME_TYPE(decltype(p1), std::pair<double, decltype(nullptr)>);
+ }
+ { // Testing (3, 6)
+ std::pair<E, decltype(nullptr)> const p(E{}, nullptr);
+ std::pair p1(p);
+ ASSERT_SAME_TYPE(decltype(p1), std::pair<E, decltype(nullptr)>);
+ }
+ { // Testing (4, 7)
+ std::pair<std::string, void*> p("abc", nullptr);
+ std::pair p1(std::move(p));
+ ASSERT_SAME_TYPE(decltype(p1), std::pair<std::string, void*>);
+ }
+ { // Testing (4, 8)
+ std::pair<std::string, E> p("abc", E{});
+ std::pair p1(std::move(p));
+ ASSERT_SAME_TYPE(decltype(p1), std::pair<std::string, E>);
+ }
+}
diff --git a/test/std/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp
index 2856190..f5d3bb6 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp
@@ -81,7 +81,7 @@
P1 p1(42, 101);
P2 p2(std::move(p1));
assert(p2.first == 42);
- assert(p2.second = 101);
+ assert(p2.second == 101);
}
{
test_pair_rv<AllCtors, AllCtors>();
diff --git a/test/std/utilities/utility/synopsis.pass.cpp b/test/std/utilities/utility/synopsis.pass.cpp
index 5f5b4ee..009b65c 100644
--- a/test/std/utilities/utility/synopsis.pass.cpp
+++ b/test/std/utilities/utility/synopsis.pass.cpp
@@ -17,5 +17,6 @@
int main()
{
std::initializer_list<int> x;
+ (void)x;
}
diff --git a/test/std/utilities/variant/variant.helpers/variant_alternative.fail.cpp b/test/std/utilities/variant/variant.helpers/variant_alternative.fail.cpp
new file mode 100644
index 0000000..31521da
--- /dev/null
+++ b/test/std/utilities/variant/variant.helpers/variant_alternative.fail.cpp
@@ -0,0 +1,32 @@
+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <variant>
+
+// template <size_t I, class T> struct variant_alternative; // undefined
+// template <size_t I, class T> struct variant_alternative<I, const T>;
+// template <size_t I, class T> struct variant_alternative<I, volatile T>;
+// template <size_t I, class T> struct variant_alternative<I, const volatile T>;
+// template <size_t I, class T>
+// using variant_alternative_t = typename variant_alternative<I, T>::type;
+//
+// template <size_t I, class... Types>
+// struct variant_alternative<I, variant<Types...>>;
+
+#include <memory>
+#include <type_traits>
+#include <variant>
+
+int main() {
+ using V = std::variant<int, void *, const void *, long double>;
+ std::variant_alternative<4, V>::type foo; // expected-error@variant:* {{Index out of bounds in std::variant_alternative<>}}
+}
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/T.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/T.pass.cpp
index d33ea0b..3f7cd4f 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/T.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/T.pass.cpp
@@ -37,6 +37,9 @@
NoThrowT(int) noexcept(true) {}
};
+struct AnyConstructible { template <typename T> AnyConstructible(T&&) {} };
+struct NoConstructible { NoConstructible() = delete; };
+
void test_T_ctor_noexcept() {
{
using V = std::variant<Dummy, NoThrowT>;
@@ -62,6 +65,17 @@
static_assert(!std::is_constructible<V, int>::value,
"no matching constructor");
}
+ {
+ using V = std::variant<AnyConstructible, NoConstructible>;
+ static_assert(
+ !std::is_constructible<V, std::in_place_type_t<NoConstructible>>::value,
+ "no matching constructor");
+ static_assert(!std::is_constructible<V, std::in_place_index_t<1>>::value,
+ "no matching constructor");
+ }
+
+
+
#if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
{
using V = std::variant<int, int &&>;
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
index f311343..1696f9c 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
@@ -261,4 +261,13 @@
test_copy_ctor_valueless_by_exception();
test_copy_ctor_sfinae();
test_constexpr_copy_ctor_extension();
+#if 0
+// disable this for the moment; it fails on older compilers.
+// Need to figure out which compilers will support it.
+{ // This is the motivating example from P0739R0
+ std::variant<int, double> v1(3);
+ std::variant v2 = v1;
+ (void) v2;
+}
+#endif
}
diff --git a/test/std/utilities/variant/variant.visit/visit.pass.cpp b/test/std/utilities/variant/variant.visit/visit.pass.cpp
index 316f2d2..c0db967 100644
--- a/test/std/utilities/variant/variant.visit/visit.pass.cpp
+++ b/test/std/utilities/variant/variant.visit/visit.pass.cpp
@@ -300,7 +300,7 @@
#endif
}
-// See http://llvm.org/PR31916
+// See https://bugs.llvm.org/show_bug.cgi?id=31916
void test_caller_accepts_nonconst() {
struct A {};
struct Visitor {
diff --git a/test/support/any_helpers.h b/test/support/any_helpers.h
index a720ecd..afc85c9 100644
--- a/test/support/any_helpers.h
+++ b/test/support/any_helpers.h
@@ -24,13 +24,13 @@
#define RTTI_ASSERT(X)
#endif
-template <class _Tp>
+template <class T>
struct IsSmallObject
: public std::integral_constant<bool
- , sizeof(_Tp) <= (sizeof(void*)*3)
+ , sizeof(T) <= (sizeof(void*)*3)
&& std::alignment_of<void*>::value
- % std::alignment_of<_Tp>::value == 0
- && std::is_nothrow_move_constructible<_Tp>::value
+ % std::alignment_of<T>::value == 0
+ && std::is_nothrow_move_constructible<T>::value
>
{};
diff --git a/test/support/container_test_types.h b/test/support/container_test_types.h
index 08e88f0..b8422ec 100644
--- a/test/support/container_test_types.h
+++ b/test/support/container_test_types.h
@@ -234,6 +234,19 @@
return &c;
}
+template <class ...Args>
+struct ExpectConstructGuard {
+ ExpectConstructGuard(int N) {
+ auto CC = getConstructController();
+ assert(!CC->unchecked());
+ CC->expect<Args...>(N);
+ }
+
+ ~ExpectConstructGuard() {
+ assert(!getConstructController()->unchecked());
+ }
+};
+
//===----------------------------------------------------------------------===//
// ContainerTestAllocator
//===----------------------------------------------------------------------===//
@@ -417,7 +430,12 @@
return arg.data;
}
};
-
+ template <class T, class Alloc>
+ class vector;
+ template <class T, class Alloc>
+ class deque;
+ template <class T, class Alloc>
+ class list;
template <class _Key, class _Value, class _Less, class _Alloc>
class map;
template <class _Key, class _Value, class _Less, class _Alloc>
@@ -444,6 +462,13 @@
// TCT - Test container type
namespace TCT {
+template <class T = CopyInsertable<1>>
+using vector = std::vector<T, ContainerTestAllocator<T, T> >;
+template <class T = CopyInsertable<1>>
+using deque = std::deque<T, ContainerTestAllocator<T, T> >;
+template <class T = CopyInsertable<1>>
+using list = std::list<T, ContainerTestAllocator<T, T> >;
+
template <class Key = CopyInsertable<1>, class Value = CopyInsertable<2>,
class ValueTp = std::pair<const Key, Value> >
using unordered_map =
@@ -488,5 +513,4 @@
} // end namespace TCT
-
#endif // SUPPORT_CONTAINER_TEST_TYPES_H
diff --git a/test/support/count_new.hpp b/test/support/count_new.hpp
index 1b05fe3..c001c03 100644
--- a/test/support/count_new.hpp
+++ b/test/support/count_new.hpp
@@ -231,12 +231,17 @@
const bool MemCounter::disable_checking = false;
#endif
-MemCounter globalMemCounter((MemCounter::MemCounterCtorArg_()));
+inline MemCounter* getGlobalMemCounter() {
+ static MemCounter counter((MemCounter::MemCounterCtorArg_()));
+ return &counter;
+}
+
+MemCounter &globalMemCounter = *getGlobalMemCounter();
#ifndef DISABLE_NEW_COUNT
void* operator new(std::size_t s) TEST_THROW_SPEC(std::bad_alloc)
{
- globalMemCounter.newCalled(s);
+ getGlobalMemCounter()->newCalled(s);
void* ret = std::malloc(s);
if (ret == nullptr)
detail::throw_bad_alloc_helper();
@@ -245,21 +250,21 @@
void operator delete(void* p) TEST_NOEXCEPT
{
- globalMemCounter.deleteCalled(p);
+ getGlobalMemCounter()->deleteCalled(p);
std::free(p);
}
void* operator new[](std::size_t s) TEST_THROW_SPEC(std::bad_alloc)
{
- globalMemCounter.newArrayCalled(s);
+ getGlobalMemCounter()->newArrayCalled(s);
return operator new(s);
}
void operator delete[](void* p) TEST_NOEXCEPT
{
- globalMemCounter.deleteArrayCalled(p);
+ getGlobalMemCounter()->deleteArrayCalled(p);
operator delete(p);
}
diff --git a/test/support/counting_predicates.hpp b/test/support/counting_predicates.hpp
index 2bd1426..050b51b 100644
--- a/test/support/counting_predicates.hpp
+++ b/test/support/counting_predicates.hpp
@@ -12,8 +12,11 @@
template <typename Predicate, typename Arg>
-struct unary_counting_predicate : public std::unary_function<Arg, bool> {
+struct unary_counting_predicate {
public:
+ typedef Arg argument_type;
+ typedef bool result_type;
+
unary_counting_predicate(Predicate p) : p_(p), count_(0) {}
~unary_counting_predicate() {}
@@ -28,8 +31,11 @@
template <typename Predicate, typename Arg1, typename Arg2=Arg1>
-struct binary_counting_predicate : public std::binary_function<Arg1, Arg2, bool> {
+struct binary_counting_predicate {
public:
+ typedef Arg1 first_argument_type;
+ typedef Arg2 second_argument_type;
+ typedef bool result_type;
binary_counting_predicate ( Predicate p ) : p_(p), count_(0) {}
~binary_counting_predicate() {}
diff --git a/test/support/emplace_constructible.h b/test/support/emplace_constructible.h
new file mode 100644
index 0000000..f0d11ba
--- /dev/null
+++ b/test/support/emplace_constructible.h
@@ -0,0 +1,74 @@
+#ifndef TEST_SUPPORT_EMPLACE_CONSTRUCTIBLE_H
+#define TEST_SUPPORT_EMPLACE_CONSTRUCTIBLE_H
+
+#include "test_macros.h"
+
+#if TEST_STD_VER >= 11
+template <class T>
+struct EmplaceConstructible {
+ T value;
+ explicit EmplaceConstructible(T xvalue) : value(xvalue) {}
+ EmplaceConstructible(EmplaceConstructible const&) = delete;
+};
+
+template <class T>
+struct EmplaceConstructibleAndMoveInsertable {
+ int copied = 0;
+ T value;
+ explicit EmplaceConstructibleAndMoveInsertable(T xvalue) : value(xvalue) {}
+
+ EmplaceConstructibleAndMoveInsertable(
+ EmplaceConstructibleAndMoveInsertable&& Other)
+ : copied(Other.copied + 1), value(std::move(Other.value)) {}
+};
+
+template <class T>
+struct EmplaceConstructibleAndMoveable {
+ int copied = 0;
+ int assigned = 0;
+ T value;
+ explicit EmplaceConstructibleAndMoveable(T xvalue) noexcept : value(xvalue) {}
+
+ EmplaceConstructibleAndMoveable(EmplaceConstructibleAndMoveable&& Other)
+ noexcept : copied(Other.copied + 1),
+ value(std::move(Other.value)) {}
+
+ EmplaceConstructibleAndMoveable&
+ operator=(EmplaceConstructibleAndMoveable&& Other) noexcept {
+ copied = Other.copied;
+ assigned = Other.assigned + 1;
+ value = std::move(Other.value);
+ return *this;
+ }
+};
+
+template <class T>
+struct EmplaceConstructibleMoveableAndAssignable {
+ int copied = 0;
+ int assigned = 0;
+ T value;
+ explicit EmplaceConstructibleMoveableAndAssignable(T xvalue) noexcept
+ : value(xvalue) {}
+
+ EmplaceConstructibleMoveableAndAssignable(
+ EmplaceConstructibleMoveableAndAssignable&& Other) noexcept
+ : copied(Other.copied + 1),
+ value(std::move(Other.value)) {}
+
+ EmplaceConstructibleMoveableAndAssignable&
+ operator=(EmplaceConstructibleMoveableAndAssignable&& Other) noexcept {
+ copied = Other.copied;
+ assigned = Other.assigned + 1;
+ value = std::move(Other.value);
+ return *this;
+ }
+
+ EmplaceConstructibleMoveableAndAssignable& operator=(T xvalue) {
+ value = std::move(xvalue);
+ ++assigned;
+ return *this;
+ }
+};
+#endif
+
+#endif // TEST_SUPPORT_EMPLACE_CONSTRUCTIBLE_H
diff --git a/test/support/experimental_any_helpers.h b/test/support/experimental_any_helpers.h
index 50bd6d6..f7bc0e3 100644
--- a/test/support/experimental_any_helpers.h
+++ b/test/support/experimental_any_helpers.h
@@ -22,13 +22,13 @@
#define RTTI_ASSERT(X)
#endif
-template <class _Tp>
+template <class T>
struct IsSmallObject
: public std::integral_constant<bool
- , sizeof(_Tp) <= (sizeof(void*)*3)
+ , sizeof(T) <= (sizeof(void*)*3)
&& std::alignment_of<void*>::value
- % std::alignment_of<_Tp>::value == 0
- && std::is_nothrow_move_constructible<_Tp>::value
+ % std::alignment_of<T>::value == 0
+ && std::is_nothrow_move_constructible<T>::value
>
{};
@@ -55,6 +55,7 @@
// Assert that an 'any' object stores the specified 'Type' and 'value'.
template <class Type>
+_LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST
void assertContains(std::experimental::any const& a, int value = 1) {
assert(!a.empty());
RTTI_ASSERT(a.type() == typeid(Type));
@@ -64,6 +65,7 @@
// Modify the value of a "test type" stored within an any to the specified
// 'value'.
template <class Type>
+_LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST
void modifyValue(std::experimental::any& a, int value) {
assert(!a.empty());
RTTI_ASSERT(a.type() == typeid(Type));
diff --git a/test/support/msvc_stdlib_force_include.hpp b/test/support/msvc_stdlib_force_include.hpp
index 954cf51..83120c7 100644
--- a/test/support/msvc_stdlib_force_include.hpp
+++ b/test/support/msvc_stdlib_force_include.hpp
@@ -54,6 +54,7 @@
// Silence compiler warnings.
#pragma warning(disable: 4180) // qualifier applied to function type has no meaning; ignored
+ #pragma warning(disable: 4324) // structure was padded due to alignment specifier
#pragma warning(disable: 4521) // multiple copy constructors specified
#pragma warning(disable: 4702) // unreachable code
#pragma warning(disable: 28251) // Inconsistent annotation for 'new': this instance has no annotations.
@@ -69,11 +70,6 @@
// atomic_is_lock_free.pass.cpp needs this VS 2015 Update 2 fix.
#define _ENABLE_ATOMIC_ALIGNMENT_FIX
- // Enable features that /std:c++latest removes by default.
- #define _HAS_AUTO_PTR_ETC 1
- #define _HAS_FUNCTION_ASSIGN 1
- #define _HAS_OLD_IOSTREAMS_MEMBERS 1
-
// Silence warnings about raw pointers and other unchecked iterators.
#define _SCL_SECURE_NO_WARNINGS
diff --git a/test/support/nasty_containers.hpp b/test/support/nasty_containers.hpp
index 99e91d6..b52263a 100644
--- a/test/support/nasty_containers.hpp
+++ b/test/support/nasty_containers.hpp
@@ -291,9 +291,9 @@
nasty_mutex() TEST_NOEXCEPT {}
~nasty_mutex() {}
- nasty_mutex *operator& () { assert(false); return nullptr; }
- template <typename T>
- void operator, (const T &) { assert(false); }
+ nasty_mutex *operator& () { assert(false); return nullptr; }
+ template <typename T>
+ void operator, (const T &) { assert(false); }
private:
nasty_mutex(const nasty_mutex&) { assert(false); }
diff --git a/test/support/platform_support.h b/test/support/platform_support.h
index a9b5b98..020cdbf 100644
--- a/test/support/platform_support.h
+++ b/test/support/platform_support.h
@@ -18,7 +18,7 @@
// locale names
#ifdef _WIN32
// WARNING: Windows does not support UTF-8 codepages.
-// Locales are "converted" using http://docs.moodle.org/dev/Table_of_locales
+// Locales are "converted" using https://docs.moodle.org/dev/Table_of_locales
#define LOCALE_en_US "en-US"
#define LOCALE_en_US_UTF_8 "en-US"
#define LOCALE_cs_CZ_ISO8859_2 "cs-CZ"
diff --git a/test/support/test_convertible.hpp b/test/support/test_convertible.hpp
index 787cef6..e0d42f7 100644
--- a/test/support/test_convertible.hpp
+++ b/test/support/test_convertible.hpp
@@ -39,4 +39,4 @@
constexpr bool test_convertible()
{ return detail::test_convertible_imp<Tp, Args...>(0); }
-#endif // SUPPORT_TEST_CONVERTIBLE_HPP
\ No newline at end of file
+#endif // SUPPORT_TEST_CONVERTIBLE_HPP
diff --git a/test/support/test_macros.h b/test/support/test_macros.h
index cc2918a..95270e4 100644
--- a/test/support/test_macros.h
+++ b/test/support/test_macros.h
@@ -81,8 +81,11 @@
# define TEST_STD_VER 11
#elif __cplusplus <= 201402L
# define TEST_STD_VER 14
+#elif __cplusplus <= 201703L
+# define TEST_STD_VER 17
#else
-# define TEST_STD_VER 16 // current year; greater than current standard
+# define TEST_STD_VER 99 // greater than current standard
+// This is deliberately different than _LIBCPP_STD_VER to discourage matching them up.
#endif
#endif
diff --git a/utils/libcxx/compiler.py b/utils/libcxx/compiler.py
index e908e26..70022d7 100644
--- a/utils/libcxx/compiler.py
+++ b/utils/libcxx/compiler.py
@@ -204,7 +204,7 @@
flags = ['-dM'] + flags
cmd, out, err, rc = self.preprocess(source_files, flags=flags, cwd=cwd)
if rc != 0:
- return None
+ return cmd, out, err, rc
parsed_macros = {}
lines = [l.strip() for l in out.split('\n') if l.strip()]
for l in lines:
diff --git a/utils/libcxx/test/config.py b/utils/libcxx/test/config.py
index 96b3df5..67927c9 100644
--- a/utils/libcxx/test/config.py
+++ b/utils/libcxx/test/config.py
@@ -259,6 +259,16 @@
compile_flags=compile_flags,
link_flags=link_flags)
+ def _dump_macros_verbose(self, *args, **kwargs):
+ macros_or_error = self.cxx.dumpMacros(*args, **kwargs)
+ if isinstance(macros_or_error, tuple):
+ cmd, out, err, rc = macros_or_error
+ report = libcxx.util.makeReport(cmd, out, err, rc)
+ report += "Compiler failed unexpectedly when dumping macros!"
+ self.lit_config.fatal(report)
+ return None
+ assert isinstance(macros_or_error, dict)
+ return macros_or_error
def configure_src_root(self):
self.libcxx_src_root = self.get_lit_conf(
@@ -440,10 +450,13 @@
# C++17 aligned allocation.
self.config.available_features.add('no-aligned-allocation')
+ if self.cxx.hasCompileFlag('-fdelayed-template-parsing'):
+ self.config.available_features.add('fdelayed-template-parsing')
+
if self.get_lit_bool('has_libatomic', False):
self.config.available_features.add('libatomic')
- macros = self.cxx.dumpMacros()
+ macros = self._dump_macros_verbose()
if '__cpp_if_constexpr' not in macros:
self.config.available_features.add('libcpp-no-if-constexpr')
@@ -466,7 +479,7 @@
# Attempt to detect the glibc version by querying for __GLIBC__
# in 'features.h'.
macros = self.cxx.dumpMacros(flags=['-include', 'features.h'])
- if macros is not None and '__GLIBC__' in macros:
+ if isinstance(macros, dict) and '__GLIBC__' in macros:
maj_v, min_v = (macros['__GLIBC__'], macros['__GLIBC_MINOR__'])
self.config.available_features.add('glibc')
self.config.available_features.add('glibc-%s' % maj_v)
@@ -624,8 +637,8 @@
"""
# Parse the macro contents of __config_site by dumping the macros
# using 'c++ -dM -E' and filtering the predefines.
- predefines = self.cxx.dumpMacros()
- macros = self.cxx.dumpMacros(header)
+ predefines = self._dump_macros_verbose()
+ macros = self._dump_macros_verbose(header)
feature_macros_keys = set(macros.keys()) - set(predefines.keys())
feature_macros = {}
for k in feature_macros_keys:
@@ -655,7 +668,10 @@
self.config.available_features.add('libcpp-abi-version-v%s'
% feature_macros[m])
continue
- assert m.startswith('_LIBCPP_HAS_') or m == '_LIBCPP_ABI_UNSTABLE'
+ if m == '_LIBCPP_NO_VCRUNTIME':
+ self.config.available_features.add('libcpp-no-vcruntime')
+ continue
+ assert m.startswith('_LIBCPP_HAS_') or m.startswith('_LIBCPP_ABI_')
m = m.lower()[1:].replace('_', '-')
self.config.available_features.add(m)
return feature_macros
@@ -888,6 +904,7 @@
self.cxx.addWarningFlagIfSupported('-Wno-c++11-extensions')
self.cxx.addWarningFlagIfSupported('-Wno-user-defined-literals')
self.cxx.addWarningFlagIfSupported('-Wno-noexcept-type')
+ self.cxx.addWarningFlagIfSupported('-Wno-aligned-allocation-unavailable')
# These warnings should be enabled in order to support the MSVC
# team using the test suite; They enable the warnings below and
# expect the test suite to be clean.
@@ -976,7 +993,7 @@
def configure_coroutines(self):
if self.cxx.hasCompileFlag('-fcoroutines-ts'):
- macros = self.cxx.dumpMacros(flags=['-fcoroutines-ts'])
+ macros = self._dump_macros_verbose(flags=['-fcoroutines-ts'])
if '__cpp_coroutines' not in macros:
self.lit_config.warning('-fcoroutines-ts is supported but '
'__cpp_coroutines is not defined')
@@ -1015,6 +1032,7 @@
cxx_path = pipes.quote(self.cxx.path)
# Configure compiler substitutions
sub.append(('%cxx', cxx_path))
+ sub.append(('%libcxx_src_root', self.libcxx_src_root))
# Configure flags substitutions
flags_str = ' '.join([pipes.quote(f) for f in self.cxx.flags])
compile_flags_str = ' '.join([pipes.quote(f) for f in self.cxx.compile_flags])
diff --git a/utils/libcxx/test/target_info.py b/utils/libcxx/test/target_info.py
index 2104432..670aea7 100644
--- a/utils/libcxx/test/target_info.py
+++ b/utils/libcxx/test/target_info.py
@@ -8,11 +8,11 @@
#===----------------------------------------------------------------------===//
import importlib
-import lit.util # pylint: disable=import-error,no-name-in-module
import locale
import os
import platform
import re
+import subprocess
import sys
class DefaultTargetInfo(object):
@@ -73,12 +73,13 @@
super(DarwinLocalTI, self).__init__(full_config)
def is_host_macosx(self):
- name = lit.util.capture(['sw_vers', '-productName']).strip()
+ name = subprocess.check_output(['sw_vers', '-productName']).strip()
return name == "Mac OS X"
def get_macosx_version(self):
assert self.is_host_macosx()
- version = lit.util.capture(['sw_vers', '-productVersion']).strip()
+ version = subprocess.check_output(
+ ['sw_vers', '-productVersion']).strip()
version = re.sub(r'([0-9]+\.[0-9]+)(\..*)?', r'\1', version)
return version
@@ -86,7 +87,7 @@
assert self.is_host_macosx()
cmd = ['xcrun', '--sdk', name, '--show-sdk-path']
try:
- out = lit.util.capture(cmd).strip()
+ out = subprocess.check_output(cmd).strip()
except OSError:
pass
@@ -127,7 +128,7 @@
else:
cmd = ['xcrun', '--show-sdk-path']
try:
- out = lit.util.capture(cmd).strip()
+ out = subprocess.check_output(cmd).strip()
res = 0
except OSError:
res = -1
@@ -168,10 +169,6 @@
# should be available in libc++ directly.
return False
- def add_sanitizer_features(self, sanitizer_type, features):
- if sanitizer_type == 'Undefined':
- features.add('sanitizer-new-delete')
-
class FreeBSDLocalTI(DefaultTargetInfo):
def __init__(self, full_config):
@@ -193,12 +190,14 @@
def platform_name(self):
name, _, _ = platform.linux_distribution()
- name = name.lower().strip()
+ # Some distros have spaces, e.g. 'SUSE Linux Enterprise Server'
+ # lit features can't have spaces
+ name = name.lower().strip().replace(' ', '-')
return name # Permitted to be None
def platform_ver(self):
_, ver, _ = platform.linux_distribution()
- ver = ver.lower().strip()
+ ver = ver.lower().strip().replace(' ', '-')
return ver # Permitted to be None.
def add_locale_features(self, features):
diff --git a/utils/merge_archives.py b/utils/merge_archives.py
index 856dd3b..58d92f0 100755
--- a/utils/merge_archives.py
+++ b/utils/merge_archives.py
@@ -94,12 +94,18 @@
help='Paths to search for the libraries along', action='append',
nargs=1)
parser.add_argument(
+ '--ar', dest='ar_exe', required=False,
+ help='The ar executable to use, finds \'ar\' in the path if not given',
+ type=str, action='store')
+ parser.add_argument(
'archives', metavar='archives', nargs='+',
help='The archives to merge')
args = parser.parse_args()
- ar_exe = distutils.spawn.find_executable('ar')
+ ar_exe = args.ar_exe
+ if not ar_exe:
+ ar_exe = distutils.spawn.find_executable('ar')
if not ar_exe:
print_and_exit("failed to find 'ar' executable")
@@ -115,13 +121,13 @@
temp_directory_root = tempfile.mkdtemp('.libcxx.merge.archives')
for arc in archives:
- execute_command_verbose([ar_exe, '-x', arc], cwd=temp_directory_root,
+ execute_command_verbose([ar_exe, 'x', arc], cwd=temp_directory_root,
verbose=args.verbose)
- files = glob.glob(os.path.join(temp_directory_root, '*.o'))
+ files = glob.glob(os.path.join(temp_directory_root, '*.o*'))
if not files:
- print_and_exit('Failed to glob for %s' % glob_path)
- cmd = [ar_exe, '-qc', args.output] + files
+ print_and_exit('Failed to glob for %s' % temp_directory_root)
+ cmd = [ar_exe, 'qcs', args.output] + files
execute_command_verbose(cmd, cwd=temp_directory_root, verbose=args.verbose)
diff --git a/www/atomic_design.html b/www/atomic_design.html
index ab5ed6e..1c6627a 100644
--- a/www/atomic_design.html
+++ b/www/atomic_design.html
@@ -12,7 +12,7 @@
<body>
<div id="menu">
<div>
- <a href="http://llvm.org/">LLVM Home</a>
+ <a href="https://llvm.org/">LLVM Home</a>
</div>
<div class="submenu">
@@ -22,11 +22,11 @@
<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="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
+ <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
<a href="https://bugs.llvm.org/">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>
+ <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
+ <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
</div>
</div>
diff --git a/www/atomic_design_a.html b/www/atomic_design_a.html
index 8175469..589ca83 100644
--- a/www/atomic_design_a.html
+++ b/www/atomic_design_a.html
@@ -12,7 +12,7 @@
<body>
<div id="menu">
<div>
- <a href="http://llvm.org/">LLVM Home</a>
+ <a href="https://llvm.org/">LLVM Home</a>
</div>
<div class="submenu">
@@ -22,11 +22,11 @@
<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="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
+ <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
<a href="https://bugs.llvm.org/">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>
+ <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
+ <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
</div>
</div>
diff --git a/www/atomic_design_b.html b/www/atomic_design_b.html
index 78c7abd..7f81f8b 100644
--- a/www/atomic_design_b.html
+++ b/www/atomic_design_b.html
@@ -12,7 +12,7 @@
<body>
<div id="menu">
<div>
- <a href="http://llvm.org/">LLVM Home</a>
+ <a href="https://llvm.org/">LLVM Home</a>
</div>
<div class="submenu">
@@ -22,11 +22,11 @@
<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="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
+ <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
<a href="https://bugs.llvm.org/">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>
+ <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
+ <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
</div>
</div>
diff --git a/www/atomic_design_c.html b/www/atomic_design_c.html
index b431917..82cc80f 100644
--- a/www/atomic_design_c.html
+++ b/www/atomic_design_c.html
@@ -12,7 +12,7 @@
<body>
<div id="menu">
<div>
- <a href="http://llvm.org/">LLVM Home</a>
+ <a href="https://llvm.org/">LLVM Home</a>
</div>
<div class="submenu">
@@ -22,11 +22,11 @@
<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="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
+ <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
<a href="https://bugs.llvm.org/">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>
+ <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
+ <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
</div>
</div>
@@ -115,7 +115,7 @@
__has_feature(__atomic_exchange_seq_cst_j) == 1
__has_feature(__atomic_store_seq_cst_j) == 1
-typedef unsigned int __atomic_flag__;
+typedef unsigned int __atomic_flag__;
unsigned int __atomic_exchange_seq_cst(unsigned int volatile*, unsigned int)
{
@@ -328,7 +328,7 @@
<p>
One should consult the (currently draft)
-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3126.pdf">C++ standard</a>
+<a href="https://wg21.link/n3126">C++ standard</a>
for the details of the definitions for these operations. For example
<tt>__atomic_compare_exchange_weak_seq_cst_seq_cst</tt> is allowed to fail
spuriously while <tt>__atomic_compare_exchange_strong_seq_cst_seq_cst</tt> is
@@ -370,7 +370,7 @@
<p>
(See the
-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3126.pdf">C++ standard</a>
+<a href="https://wg21.link/n3126">C++ standard</a>
for the detailed definitions of each of these orderings).
</p>
diff --git a/www/cxx1y_status.html b/www/cxx1y_status.html
index 28fd239..0bcd179 100644
--- a/www/cxx1y_status.html
+++ b/www/cxx1y_status.html
@@ -12,7 +12,7 @@
<body>
<div id="menu">
<div>
- <a href="http://llvm.org/">LLVM Home</a>
+ <a href="https://llvm.org/">LLVM Home</a>
</div>
<div class="submenu">
@@ -22,11 +22,11 @@
<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="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
+ <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
<a href="https://bugs.llvm.org/">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>
+ <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
+ <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
</div>
</div>
@@ -37,7 +37,7 @@
<p>In April 2013, the C++ standard committee approved the draft for the next version of the C++ standard, known as "C++1Y" (probably to be C++14)</p>
<p>The draft standard includes papers and issues that were voted on at the previous three meetings (Kona, Portland, and Bristol)</p>
- <p>This page shows the status of libc++; the status of clang's support of the language features is <a href="http://clang.llvm.org/cxx_status.html">here</a>.</p>
+ <p>This page shows the status of libc++; the status of clang's support of the language features is <a href="https://clang.llvm.org/cxx_status.html">here</a>.</p>
<p>The groups that have contributed papers:
<ul>
@@ -46,22 +46,22 @@
<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><a href="https://wg21.link/n3346">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>
<!-- <tr><td>3323</td><td>CWG</td><td>A Proposal to Tweak Certain C++ Contextual Conversions, v3</td><td>Portland</td><td></td><td></td></tr> -->
-
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3421.htm">3421</a></td><td>LWG</td><td>Making Operator Functors greater<></td><td>Portland</td><td>Complete</td><td>3.4</td></tr>
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3462.html">3462</a></td><td>LWG</td><td>std::result_of and SFINAE</td><td>Portland</td><td>Complete</td><td>3.4</td></tr>
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3469.html">3469</a></td><td>LWG</td><td>Constexpr Library Additions: chrono, v3</td><td>Portland</td><td>Complete</td><td>3.4</td></tr>
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3470.html">3470</a></td><td>LWG</td><td>Constexpr Library Additions: containers, v2</td><td>Portland</td><td>Complete</td><td>3.4</td></tr>
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3471.html">3471</a></td><td>LWG</td><td>Constexpr Library Additions: utilities, v3</td><td>Portland</td><td>Complete</td><td>3.4</td></tr>
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3302.html">3302</a></td><td>LWG</td><td>Constexpr Library Additions: complex, v2</td><td>Portland</td><td>Complete</td><td>3.4</td></tr>
+
+ <tr><td><a href="https://wg21.link/n3421">3421</a></td><td>LWG</td><td>Making Operator Functors greater<></td><td>Portland</td><td>Complete</td><td>3.4</td></tr>
+ <tr><td><a href="https://wg21.link/n3462">3462</a></td><td>LWG</td><td>std::result_of and SFINAE</td><td>Portland</td><td>Complete</td><td>3.4</td></tr>
+ <tr><td><a href="https://wg21.link/n3469">3469</a></td><td>LWG</td><td>Constexpr Library Additions: chrono, v3</td><td>Portland</td><td>Complete</td><td>3.4</td></tr>
+ <tr><td><a href="https://wg21.link/n3470">3470</a></td><td>LWG</td><td>Constexpr Library Additions: containers, v2</td><td>Portland</td><td>Complete</td><td>3.4</td></tr>
+ <tr><td><a href="https://wg21.link/n3471">3471</a></td><td>LWG</td><td>Constexpr Library Additions: utilities, v3</td><td>Portland</td><td>Complete</td><td>3.4</td></tr>
+ <tr><td><a href="https://wg21.link/n3302">3302</a></td><td>LWG</td><td>Constexpr Library Additions: complex, v2</td><td>Portland</td><td>Complete</td><td>3.4</td></tr>
<tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
<!-- <tr><td>3472</td><td>CWG</td><td>Binary Literals in the C++ Core Language</td><td>Bristol</td><td></td><td></td></tr> -->
@@ -75,32 +75,32 @@
<!-- <tr><td>3664</td><td>CWG</td><td>Clarifying Memory Allocation</td><td>Bristol</td><td></td><td></td></tr> -->
<!-- <tr><td>3651</td><td>CWG</td><td>Variable Templates (Revision 1)</td><td>Bristol</td><td></td><td></td></tr> -->
<!-- <tr><td>3649</td><td>CWG</td><td>Generic (Polymorphic) Lambda Expressions (Revision 3)</td><td>Bristol</td><td></td><td></td></tr> -->
-
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3545.pdf">3545</a></td><td>LWG</td><td>An Incremental Improvement to integral_constant</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3644.pdf">3644</a></td><td>LWG</td><td>Null Forward Iterators</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3668.html">3668</a></td><td>LWG</td><td>std::exchange()</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3658.html">3658</a></td><td>LWG</td><td>Compile-time integer sequences</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3670.html">3670</a></td><td>LWG</td><td>Addressing Tuples by Type</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3671.html">3671</a></td><td>LWG</td><td>Making non-modifying sequence operations more robust</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3656.htm">3656</a></td><td>LWG</td><td>make_unique</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3654.html">3654</a></td><td>LWG</td><td>Quoted Strings</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3642.pdf">3642</a></td><td>LWG</td><td>User-defined Literals</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3655.pdf">3655</a></td><td>LWG</td><td>TransformationTraits Redux (excluding part 4)</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3657.htm">3657</a></td><td>LWG</td><td>Adding heterogeneous comparison lookup to associative containers</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3672.html">3672</a></td><td>LWG</td><td>A proposal to add a utility class to represent optional objects</td><td>Bristol</td><td><I>Removed from Draft Standard</I></td><td>n/a</td></tr>
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3669.pdf">3669</a></td><td>LWG</td><td>Fixing constexpr member functions without const</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3662.html">3662</a></td><td>LWG</td><td>C++ Dynamic Arrays (dynarray)</td><td>Bristol</td><td><I>Removed from Draft Standard</I></td><td>n/a</td></tr>
-
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3659.html">3659</a></td><td>SG1</td><td>Shared Locking in C++</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
+
+ <tr><td><a href="https://wg21.link/n3545">3545</a></td><td>LWG</td><td>An Incremental Improvement to integral_constant</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
+ <tr><td><a href="https://wg21.link/n3644">3644</a></td><td>LWG</td><td>Null Forward Iterators</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
+ <tr><td><a href="https://wg21.link/n3668">3668</a></td><td>LWG</td><td>std::exchange()</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
+ <tr><td><a href="https://wg21.link/n3658">3658</a></td><td>LWG</td><td>Compile-time integer sequences</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
+ <tr><td><a href="https://wg21.link/n3670">3670</a></td><td>LWG</td><td>Addressing Tuples by Type</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
+ <tr><td><a href="https://wg21.link/n3671">3671</a></td><td>LWG</td><td>Making non-modifying sequence operations more robust</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
+ <tr><td><a href="https://wg21.link/n3656">3656</a></td><td>LWG</td><td>make_unique</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
+ <tr><td><a href="https://wg21.link/n3654">3654</a></td><td>LWG</td><td>Quoted Strings</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
+ <tr><td><a href="https://wg21.link/n3642">3642</a></td><td>LWG</td><td>User-defined Literals</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
+ <tr><td><a href="https://wg21.link/n3655">3655</a></td><td>LWG</td><td>TransformationTraits Redux (excluding part 4)</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
+ <tr><td><a href="https://wg21.link/n3657">3657</a></td><td>LWG</td><td>Adding heterogeneous comparison lookup to associative containers</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
+ <tr><td><a href="https://wg21.link/n3672">3672</a></td><td>LWG</td><td>A proposal to add a utility class to represent optional objects</td><td>Bristol</td><td><I>Removed from Draft Standard</I></td><td>n/a</td></tr>
+ <tr><td><a href="https://wg21.link/n3669">3669</a></td><td>LWG</td><td>Fixing constexpr member functions without const</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
+ <tr><td><a href="https://wg21.link/n3662">3662</a></td><td>LWG</td><td>C++ Dynamic Arrays (dynarray)</td><td>Bristol</td><td><I>Removed from Draft Standard</I></td><td>n/a</td></tr>
+
+ <tr><td><a href="https://wg21.link/n3659">3659</a></td><td>SG1</td><td>Shared Locking in C++</td><td>Bristol</td><td>Complete</td><td>3.4</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/2013/n3779.pdf">3779</a></td><td>LWG</td><td>User-defined Literals for std::complex</td><td>Chicago</td><td>Complete</td><td>3.4</td></tr>
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3789.htm">3789</a></td><td>LWG</td><td>Constexpr Library Additions: functional</td><td>Chicago</td><td>Complete</td><td>3.4</td></tr>
+ <tr><td><a href="https://wg21.link/n3779">3779</a></td><td>LWG</td><td>User-defined Literals for std::complex</td><td>Chicago</td><td>Complete</td><td>3.4</td></tr>
+ <tr><td><a href="https://wg21.link/n3789">3789</a></td><td>LWG</td><td>Constexpr Library Additions: functional</td><td>Chicago</td><td>Complete</td><td>3.4</td></tr>
<tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
- <tr><td><a href="http://isocpp.org/files/papers/N3924.pdf">3924</a></td><td>LWG</td><td>Discouraging rand() in C++14</td><td>Issaquah</td><td>Complete</td><td>3.5</td></tr>
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3887">3887</a></td><td>LWG</td><td>Consistent Metafunction Aliases</td><td>Issaquah</td><td>Complete</td><td>3.5</td></tr>
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3891">3891</a></td><td>SG1</td><td>A proposal to rename shared_mutex to shared_timed_mutex</td><td>Issaquah</td><td>Complete</td><td>3.5</td></tr>
+ <tr><td><a href="https://wg21.link/n3924">3924</a></td><td>LWG</td><td>Discouraging rand() in C++14</td><td>Issaquah</td><td>Complete</td><td>3.5</td></tr>
+ <tr><td><a href="https://wg21.link/n3887">3887</a></td><td>LWG</td><td>Consistent Metafunction Aliases</td><td>Issaquah</td><td>Complete</td><td>3.5</td></tr>
+ <tr><td><a href="https://wg21.link/n3891">3891</a></td><td>SG1</td><td>A proposal to rename shared_mutex to shared_timed_mutex</td><td>Issaquah</td><td>Complete</td><td>3.5</td></tr>
<!-- <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr> -->
</table>
@@ -109,165 +109,165 @@
<!-- <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#1214">1214</a></td><td>Insufficient/inconsistent key immutability requirements for associative containers</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2009">2009</a></td><td>Reporting out-of-bound values on numeric string conversions</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2010">2010</a></td><td>is_* traits for binding operations can't be meaningfully specialized</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2015">2015</a></td><td>Incorrect pre-conditions for some type traits</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2021">2021</a></td><td>Further incorrect usages of result_of</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2028">2028</a></td><td>messages_base::catalog overspecified</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2033">2033</a></td><td>Preconditions of reserve, shrink_to_fit, and resize functions</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2039">2039</a></td><td>Issues with std::reverse and std::copy_if</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2044">2044</a></td><td>No definition of "Stable" for copy algorithms</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2045">2045</a></td><td>forward_list::merge and forward_list::splice_after with unequal allocators</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2047">2047</a></td><td>Incorrect "mixed" move-assignment semantics of unique_ptr</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2050">2050</a></td><td>Unordered associative containers do not use allocator_traits to define member types</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2053">2053</a></td><td>Errors in regex bitmask types</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2061">2061</a></td><td>make_move_iterator and arrays</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2064">2064</a></td><td>More noexcept issues in basic_string</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2065">2065</a></td><td>Minimal allocator interface</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2067">2067</a></td><td>packaged_task should have deleted copy c'tor with const parameter</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2069">2069</a></td><td>Inconsistent exception spec for basic_string move constructor</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2096">2096</a></td><td>Incorrect constraints of future::get in regard to MoveAssignable</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2102">2102</a></td><td>Why is std::launch an implementation-defined type?</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg1214">1214</a></td><td>Insufficient/inconsistent key immutability requirements for associative containers</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2009">2009</a></td><td>Reporting out-of-bound values on numeric string conversions</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2010">2010</a></td><td>is_* traits for binding operations can't be meaningfully specialized</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2015">2015</a></td><td>Incorrect pre-conditions for some type traits</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2021">2021</a></td><td>Further incorrect usages of result_of</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2028">2028</a></td><td>messages_base::catalog overspecified</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2033">2033</a></td><td>Preconditions of reserve, shrink_to_fit, and resize functions</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2039">2039</a></td><td>Issues with std::reverse and std::copy_if</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2044">2044</a></td><td>No definition of "Stable" for copy algorithms</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2045">2045</a></td><td>forward_list::merge and forward_list::splice_after with unequal allocators</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2047">2047</a></td><td>Incorrect "mixed" move-assignment semantics of unique_ptr</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2050">2050</a></td><td>Unordered associative containers do not use allocator_traits to define member types</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2053">2053</a></td><td>Errors in regex bitmask types</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2061">2061</a></td><td>make_move_iterator and arrays</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2064">2064</a></td><td>More noexcept issues in basic_string</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2065">2065</a></td><td>Minimal allocator interface</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2067">2067</a></td><td>packaged_task should have deleted copy c'tor with const parameter</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2069">2069</a></td><td>Inconsistent exception spec for basic_string move constructor</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2096">2096</a></td><td>Incorrect constraints of future::get in regard to MoveAssignable</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2102">2102</a></td><td>Why is std::launch an implementation-defined type?</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#2071">2071</a></td><td>std::valarray move-assignment</td><td>Portland</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2074">2074</a></td><td>Off by one error in std::reverse_copy</td><td>Portland</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2081">2081</a></td><td>Allocator requirements should include CopyConstructible</td><td>Portland</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2083">2083</a></td><td>const-qualification on weak_ptr::owner_before</td><td>Portland</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2086">2086</a></td><td>Overly generic type support for math functions</td><td>Portland</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2099">2099</a></td><td>Unnecessary constraints of va_start() usage</td><td>Portland</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2103">2103</a></td><td>std::allocator_traits<std::allocator<T>>::propagate_on_container_move_assignment</td><td>Portland</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2105">2105</a></td><td>Inconsistent requirements on const_iterator's value_type</td><td>Portland</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2110">2110</a></td><td>remove can't swap but note says it might</td><td>Portland</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2123">2123</a></td><td>merge() allocator requirements for lists versus forward lists</td><td>Portland</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2005">2005</a></td><td>unordered_map::insert(T&&) protection should apply to map too</td><td>Portland</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2011">2011</a></td><td>Unexpected output required of strings</td><td>Portland</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2048">2048</a></td><td>Unnecessary mem_fn overloads</td><td>Portland</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2049">2049</a></td><td>is_destructible is underspecified</td><td>Portland</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2056">2056</a></td><td>future_errc enums start with value 0 (invalid value for broken_promise)</td><td>Portland</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2058">2058</a></td><td>valarray and begin/end</td><td>Portland</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2071">2071</a></td><td>std::valarray move-assignment</td><td>Portland</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2074">2074</a></td><td>Off by one error in std::reverse_copy</td><td>Portland</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2081">2081</a></td><td>Allocator requirements should include CopyConstructible</td><td>Portland</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2083">2083</a></td><td>const-qualification on weak_ptr::owner_before</td><td>Portland</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2086">2086</a></td><td>Overly generic type support for math functions</td><td>Portland</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2099">2099</a></td><td>Unnecessary constraints of va_start() usage</td><td>Portland</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2103">2103</a></td><td>std::allocator_traits<std::allocator<T>>::propagate_on_container_move_assignment</td><td>Portland</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2105">2105</a></td><td>Inconsistent requirements on const_iterator's value_type</td><td>Portland</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2110">2110</a></td><td>remove can't swap but note says it might</td><td>Portland</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2123">2123</a></td><td>merge() allocator requirements for lists versus forward lists</td><td>Portland</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2005">2005</a></td><td>unordered_map::insert(T&&) protection should apply to map too</td><td>Portland</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2011">2011</a></td><td>Unexpected output required of strings</td><td>Portland</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2048">2048</a></td><td>Unnecessary mem_fn overloads</td><td>Portland</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2049">2049</a></td><td>is_destructible is underspecified</td><td>Portland</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2056">2056</a></td><td>future_errc enums start with value 0 (invalid value for broken_promise)</td><td>Portland</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2058">2058</a></td><td>valarray and begin/end</td><td>Portland</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#2091">2091</a></td><td>Misplaced effect in m.try_lock_for()</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2092">2092</a></td><td>Vague Wording for condition_variable_any</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2093">2093</a></td><td>Throws clause of condition_variable::wait with predicate</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2094">2094</a></td><td>duration conversion overflow shouldn't participate in overload resolution</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2122">2122</a></td><td>merge() stability for lists versus forward lists</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2128">2128</a></td><td>Absence of global functions cbegin/cend</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2145">2145</a></td><td>error_category default constructor</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2147">2147</a></td><td>Unclear hint type in Allocator's allocate function</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2148">2148</a></td><td>Hashing enums should be supported directly by std::hash</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2149">2149</a></td><td>Concerns about 20.8/5</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2162">2162</a></td><td>allocator_traits::max_size missing noexcept</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2163">2163</a></td><td>nth_element requires inconsistent post-conditions</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2169">2169</a></td><td>Missing reset() requirements in unique_ptr specialization</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2172">2172</a></td><td>Does atomic_compare_exchange_* accept v == nullptr arguments?</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2080">2080</a></td><td>Specify when once_flag becomes invalid</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2098">2098</a></td><td>promise throws clauses</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2109">2109</a></td><td>Incorrect requirements for hash specializations</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2130">2130</a></td><td>missing ordering constraints for fences</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2138">2138</a></td><td>atomic_flag::clear ordering constraints</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2140">2140</a></td><td>notify_all_at_thread_exit synchronization</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2144">2144</a></td><td>Missing noexcept specification in type_index</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2174">2174</a></td><td>wstring_convert::converted() should be noexcept</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2175">2175</a></td><td>string_convert and wbuffer_convert validity</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2176">2176</a></td><td>Special members for wstring_convert and wbuffer_convert</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2177">2177</a></td><td>Requirements on Copy/MoveInsertable</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2185">2185</a></td><td>Missing throws clause for future/shared_future::wait_for/wait_until</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2187">2187</a></td><td>vector<bool> is missing emplace and emplace_back member functions</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2190">2190</a></td><td>ordering of condition variable operations, reflects Posix discussion</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2196">2196</a></td><td>Specification of is_*[copy/move]_[constructible/assignable] unclear for non-referencable types</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2197">2197</a></td><td>Specification of is_[un]signed unclear for non-arithmetic types</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2200">2200</a></td><td>Data race avoidance for all containers, not only for sequences</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2203">2203</a></td><td>scoped_allocator_adaptor uses wrong argument types for piecewise construction</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2207">2207</a></td><td>basic_string::at should not have a Requires clause</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2209">2209</a></td><td>assign() overspecified for sequence containers</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2210">2210</a></td><td>Missing allocator-extended constructor for allocator-aware containers</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2211">2211</a></td><td>Replace ambiguous use of "Allocator" in container requirements</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2222">2222</a></td><td>Inconsistency in description of forward_list::splice_after single-element overload</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2225">2225</a></td><td>Unrealistic header inclusion checks required</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2229">2229</a></td><td>Standard code conversion facets underspecified</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2231">2231</a></td><td>DR 704 removes complexity guarantee for clear()</td><td>Bristol</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2235">2235</a></td><td>Undefined behavior without proper requirements on basic_string constructors</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2091">2091</a></td><td>Misplaced effect in m.try_lock_for()</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2092">2092</a></td><td>Vague Wording for condition_variable_any</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2093">2093</a></td><td>Throws clause of condition_variable::wait with predicate</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2094">2094</a></td><td>duration conversion overflow shouldn't participate in overload resolution</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2122">2122</a></td><td>merge() stability for lists versus forward lists</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2128">2128</a></td><td>Absence of global functions cbegin/cend</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2145">2145</a></td><td>error_category default constructor</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2147">2147</a></td><td>Unclear hint type in Allocator's allocate function</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2148">2148</a></td><td>Hashing enums should be supported directly by std::hash</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2149">2149</a></td><td>Concerns about 20.8/5</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2162">2162</a></td><td>allocator_traits::max_size missing noexcept</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2163">2163</a></td><td>nth_element requires inconsistent post-conditions</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2169">2169</a></td><td>Missing reset() requirements in unique_ptr specialization</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2172">2172</a></td><td>Does atomic_compare_exchange_* accept v == nullptr arguments?</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2080">2080</a></td><td>Specify when once_flag becomes invalid</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2098">2098</a></td><td>promise throws clauses</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2109">2109</a></td><td>Incorrect requirements for hash specializations</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2130">2130</a></td><td>missing ordering constraints for fences</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2138">2138</a></td><td>atomic_flag::clear ordering constraints</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2140">2140</a></td><td>notify_all_at_thread_exit synchronization</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2144">2144</a></td><td>Missing noexcept specification in type_index</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2174">2174</a></td><td>wstring_convert::converted() should be noexcept</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2175">2175</a></td><td>string_convert and wbuffer_convert validity</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2176">2176</a></td><td>Special members for wstring_convert and wbuffer_convert</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2177">2177</a></td><td>Requirements on Copy/MoveInsertable</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2185">2185</a></td><td>Missing throws clause for future/shared_future::wait_for/wait_until</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2187">2187</a></td><td>vector<bool> is missing emplace and emplace_back member functions</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2190">2190</a></td><td>ordering of condition variable operations, reflects Posix discussion</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2196">2196</a></td><td>Specification of is_*[copy/move]_[constructible/assignable] unclear for non-referencable types</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2197">2197</a></td><td>Specification of is_[un]signed unclear for non-arithmetic types</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2200">2200</a></td><td>Data race avoidance for all containers, not only for sequences</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2203">2203</a></td><td>scoped_allocator_adaptor uses wrong argument types for piecewise construction</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2207">2207</a></td><td>basic_string::at should not have a Requires clause</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2209">2209</a></td><td>assign() overspecified for sequence containers</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2210">2210</a></td><td>Missing allocator-extended constructor for allocator-aware containers</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2211">2211</a></td><td>Replace ambiguous use of "Allocator" in container requirements</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2222">2222</a></td><td>Inconsistency in description of forward_list::splice_after single-element overload</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2225">2225</a></td><td>Unrealistic header inclusion checks required</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2229">2229</a></td><td>Standard code conversion facets underspecified</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2231">2231</a></td><td>DR 704 removes complexity guarantee for clear()</td><td>Bristol</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2235">2235</a></td><td>Undefined behavior without proper requirements on basic_string constructors</td><td>Bristol</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#2141">2141</a></td><td>common_type trait produces reference types</td><td>Chicago</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2246">2246</a></td><td>unique_ptr assignment effects w.r.t. deleter</td><td>Chicago</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2247">2247</a></td><td>Type traits and std::nullptr_t</td><td>Chicago</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2085">2085</a></td><td>Wrong description of effect 1 of basic_istream::ignore</td><td>Chicago</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2087">2087</a></td><td>iostream_category() and noexcept</td><td>Chicago</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2143">2143</a></td><td>ios_base::xalloc should be thread-safe</td><td>Chicago</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2150">2150</a></td><td>Unclear specification of find_end</td><td>Chicago</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2180">2180</a></td><td>Exceptions from std::seed_seq operations</td><td>Chicago</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2194">2194</a></td><td>Impossible container requirements for adaptor types</td><td>Chicago</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2013">2013</a></td><td>Do library implementers have the freedom to add constexpr?</td><td>Chicago</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2018">2018</a></td><td>regex_traits::isctype Returns clause is wrong</td><td>Chicago</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2078">2078</a></td><td>Throw specification of async() incomplete</td><td>Chicago</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2097">2097</a></td><td>packaged_task constructors should be constrained</td><td>Chicago</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2100">2100</a></td><td>Timed waiting functions cannot timeout if launch::async policy used</td><td>Chicago</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2120">2120</a></td><td>What should async do if neither 'async' nor 'deferred' is set in policy?</td><td>Chicago</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2159">2159</a></td><td>atomic_flag initialization</td><td>Chicago</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2275">2275</a></td><td>Why is forward_as_tuple not constexpr?</td><td>Chicago</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2284">2284</a></td><td>Inconsistency in allocator_traits::max_size</td><td>Chicago</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2298">2298</a></td><td>is_nothrow_constructible is always false because of create<></td><td>Chicago</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2300">2300</a></td><td>Redundant sections for map and multimap members should be removed</td><td>Chicago</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2141">2141</a></td><td>common_type trait produces reference types</td><td>Chicago</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2246">2246</a></td><td>unique_ptr assignment effects w.r.t. deleter</td><td>Chicago</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2247">2247</a></td><td>Type traits and std::nullptr_t</td><td>Chicago</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2085">2085</a></td><td>Wrong description of effect 1 of basic_istream::ignore</td><td>Chicago</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2087">2087</a></td><td>iostream_category() and noexcept</td><td>Chicago</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2143">2143</a></td><td>ios_base::xalloc should be thread-safe</td><td>Chicago</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2150">2150</a></td><td>Unclear specification of find_end</td><td>Chicago</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2180">2180</a></td><td>Exceptions from std::seed_seq operations</td><td>Chicago</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2194">2194</a></td><td>Impossible container requirements for adaptor types</td><td>Chicago</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2013">2013</a></td><td>Do library implementers have the freedom to add constexpr?</td><td>Chicago</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2018">2018</a></td><td>regex_traits::isctype Returns clause is wrong</td><td>Chicago</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2078">2078</a></td><td>Throw specification of async() incomplete</td><td>Chicago</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2097">2097</a></td><td>packaged_task constructors should be constrained</td><td>Chicago</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2100">2100</a></td><td>Timed waiting functions cannot timeout if launch::async policy used</td><td>Chicago</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2120">2120</a></td><td>What should async do if neither 'async' nor 'deferred' is set in policy?</td><td>Chicago</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2159">2159</a></td><td>atomic_flag initialization</td><td>Chicago</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2275">2275</a></td><td>Why is forward_as_tuple not constexpr?</td><td>Chicago</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2284">2284</a></td><td>Inconsistency in allocator_traits::max_size</td><td>Chicago</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2298">2298</a></td><td>is_nothrow_constructible is always false because of create<></td><td>Chicago</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2300">2300</a></td><td>Redundant sections for map and multimap members should be removed</td><td>Chicago</td><td>Complete</td></tr>
<tr><td>NB comment: GB9</td> <td>Remove gets from C++14</td><td>Chicago</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#2135">2135</a></td><td>Unclear requirement for exceptions thrown in condition_variable::wait()</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2291">2291</a></td><td>std::hash is vulnerable to collision DoS attack</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2142">2142</a></td><td>packaged_task::operator() synchronization too broad?</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2240">2240</a></td><td>Probable misuse of term "function scope" in [thread.condition]</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2252">2252</a></td><td>Strong guarantee on vector::push_back() still broken with C++11?</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2257">2257</a></td><td>Simplify container requirements with the new algorithms</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2268">2268</a></td><td>Setting a default argument in the declaration of a member function assign of std::basic_string</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2271">2271</a></td><td>regex_traits::lookup_classname specification unclear</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2272">2272</a></td><td>quoted should use char_traits::eq for character comparison</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2278">2278</a></td><td>User-defined literals for Standard Library types</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2280">2280</a></td><td>begin / end for arrays should be constexpr and noexcept</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2285">2285</a></td><td>make_reverse_iterator</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2135">2135</a></td><td>Unclear requirement for exceptions thrown in condition_variable::wait()</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2291">2291</a></td><td>std::hash is vulnerable to collision DoS attack</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2142">2142</a></td><td>packaged_task::operator() synchronization too broad?</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2240">2240</a></td><td>Probable misuse of term "function scope" in [thread.condition]</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2252">2252</a></td><td>Strong guarantee on vector::push_back() still broken with C++11?</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2257">2257</a></td><td>Simplify container requirements with the new algorithms</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2268">2268</a></td><td>Setting a default argument in the declaration of a member function assign of std::basic_string</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2271">2271</a></td><td>regex_traits::lookup_classname specification unclear</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2272">2272</a></td><td>quoted should use char_traits::eq for character comparison</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2278">2278</a></td><td>User-defined literals for Standard Library types</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2280">2280</a></td><td>begin / end for arrays should be constexpr and noexcept</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2285">2285</a></td><td>make_reverse_iterator</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2299">2299</a></td><td>Effects of inaccessible key_compare::is_transparent type are not clear</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2299">2299</a></td><td>Effects of inaccessible key_compare::is_transparent type are not clear</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#1450">1450</a></td><td>Contradiction in regex_constants</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2003">2003</a></td><td>String exception inconsistency in erase.</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2112">2112</a></td><td>User-defined classes that cannot be derived from</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2132">2132</a></td><td>std::function ambiguity</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2182">2182</a></td><td>Container::[const_]reference types are misleadingly specified</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2188">2188</a></td><td>Reverse iterator does not fully support targets that overload operator&</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2193">2193</a></td><td>Default constructors for standard library containers are explicit</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2205">2205</a></td><td>Problematic postconditions of regex_match and regex_search</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2213">2213</a></td><td>Return value of std::regex_replace</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg1450">1450</a></td><td>Contradiction in regex_constants</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2003">2003</a></td><td>String exception inconsistency in erase.</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2112">2112</a></td><td>User-defined classes that cannot be derived from</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2132">2132</a></td><td>std::function ambiguity</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2182">2182</a></td><td>Container::[const_]reference types are misleadingly specified</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2188">2188</a></td><td>Reverse iterator does not fully support targets that overload operator&</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2193">2193</a></td><td>Default constructors for standard library containers are explicit</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2205">2205</a></td><td>Problematic postconditions of regex_match and regex_search</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2213">2213</a></td><td>Return value of std::regex_replace</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2258">2258</a></td><td>a.erase(q1, q2) unable to directly return q2</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2263">2263</a></td><td>Comparing iterators and allocator pointers with different const-character</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2293">2293</a></td><td>Wrong facet used by num_put::do_put</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2301">2301</a></td><td>Why is std::tie not constexpr?</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2304">2304</a></td><td>Complexity of count in unordered associative containers</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2306">2306</a></td><td>match_results::reference should be value_type&, not const value_type&</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2308">2308</a></td><td>Clarify container destructor requirements w.r.t. std::array</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2313">2313</a></td><td>tuple_size should always derive from integral_constant<size_t, N></td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2314">2314</a></td><td>apply() should return decltype(auto) and use decay_t before tuple_size</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2315">2315</a></td><td>weak_ptr should be movable</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2316">2316</a></td><td>weak_ptr::lock() should be atomic</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2317">2317</a></td><td>The type property queries should be UnaryTypeTraits returning size_t</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2320">2320</a></td><td>select_on_container_copy_construction() takes allocators, not containers</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2322">2322</a></td><td>Associative(initializer_list, stuff) constructors are underspecified</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2323">2323</a></td><td>vector::resize(n, t)'s specification should be simplified</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2324">2324</a></td><td>Insert iterator constructors should use addressof()</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2329">2329</a></td><td>regex_match()/regex_search() with match_results should forbid temporary strings</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2330">2330</a></td><td>regex("meow", regex::icase) is technically forbidden but should be permitted</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2332">2332</a></td><td>regex_iterator/regex_token_iterator should forbid temporary regexes</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2339">2339</a></td><td>Wording issue in nth_element</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2341">2341</a></td><td>Inconsistency between basic_ostream::seekp(pos) and basic_ostream::seekp(off, dir)</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2344">2344</a></td><td>quoted()'s interaction with padding is unclear</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2346">2346</a></td><td>integral_constant's member functions should be marked noexcept</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2350">2350</a></td><td>min, max, and minmax should be constexpr</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2356">2356</a></td><td>Stability of erasure in unordered associative containers</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2357">2357</a></td><td>Remaining "Assignable" requirement</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2359">2359</a></td><td>How does regex_constants::nosubs affect basic_regex::mark_count()?</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2360">2360</a></td><td>reverse_iterator::operator*() is unimplementable</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2104">2104</a></td><td>unique_lock move-assignment should not be noexcept</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2186">2186</a></td><td>Incomplete action on async/launch::deferred</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2075">2075</a></td><td>Progress guarantees, lock-free property, and scheduling assumptions</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2288">2288</a></td><td>Inconsistent requirements for shared mutexes</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2258">2258</a></td><td>a.erase(q1, q2) unable to directly return q2</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2263">2263</a></td><td>Comparing iterators and allocator pointers with different const-character</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2293">2293</a></td><td>Wrong facet used by num_put::do_put</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2301">2301</a></td><td>Why is std::tie not constexpr?</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2304">2304</a></td><td>Complexity of count in unordered associative containers</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2306">2306</a></td><td>match_results::reference should be value_type&, not const value_type&</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2308">2308</a></td><td>Clarify container destructor requirements w.r.t. std::array</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2313">2313</a></td><td>tuple_size should always derive from integral_constant<size_t, N></td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2314">2314</a></td><td>apply() should return decltype(auto) and use decay_t before tuple_size</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2315">2315</a></td><td>weak_ptr should be movable</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2316">2316</a></td><td>weak_ptr::lock() should be atomic</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2317">2317</a></td><td>The type property queries should be UnaryTypeTraits returning size_t</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2320">2320</a></td><td>select_on_container_copy_construction() takes allocators, not containers</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2322">2322</a></td><td>Associative(initializer_list, stuff) constructors are underspecified</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2323">2323</a></td><td>vector::resize(n, t)'s specification should be simplified</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2324">2324</a></td><td>Insert iterator constructors should use addressof()</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2329">2329</a></td><td>regex_match()/regex_search() with match_results should forbid temporary strings</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2330">2330</a></td><td>regex("meow", regex::icase) is technically forbidden but should be permitted</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2332">2332</a></td><td>regex_iterator/regex_token_iterator should forbid temporary regexes</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2339">2339</a></td><td>Wording issue in nth_element</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2341">2341</a></td><td>Inconsistency between basic_ostream::seekp(pos) and basic_ostream::seekp(off, dir)</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2344">2344</a></td><td>quoted()'s interaction with padding is unclear</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2346">2346</a></td><td>integral_constant's member functions should be marked noexcept</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2350">2350</a></td><td>min, max, and minmax should be constexpr</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2356">2356</a></td><td>Stability of erasure in unordered associative containers</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2357">2357</a></td><td>Remaining "Assignable" requirement</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2359">2359</a></td><td>How does regex_constants::nosubs affect basic_regex::mark_count()?</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2360">2360</a></td><td>reverse_iterator::operator*() is unimplementable</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2104">2104</a></td><td>unique_lock move-assignment should not be noexcept</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2186">2186</a></td><td>Incomplete action on async/launch::deferred</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2075">2075</a></td><td>Progress guarantees, lock-free property, and scheduling assumptions</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/lwg2288">2288</a></td><td>Inconsistent requirements for shared mutexes</td><td>Issaquah</td><td>Complete</td></tr>
<!-- <tr><td></td><td></td><td></td><td></td></tr> -->
</table>
diff --git a/www/cxx1z_status.html b/www/cxx1z_status.html
index bd33b6e..ca4801b 100644
--- a/www/cxx1z_status.html
+++ b/www/cxx1z_status.html
@@ -12,7 +12,7 @@
<body>
<div id="menu">
<div>
- <a href="http://llvm.org/">LLVM Home</a>
+ <a href="https://llvm.org/">LLVM Home</a>
</div>
<div class="submenu">
@@ -22,11 +22,11 @@
<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="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
+ <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
<a href="https://bugs.llvm.org/">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>
+ <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
+ <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
</div>
</div>
@@ -37,7 +37,9 @@
<p>In November 2014, the C++ standard committee created a draft for the next version of the C++ standard, known here as "C++1z" (probably to be C++17).</p>
<p>In February 2017, the C++ standard committee approved this draft, and sent it to ISO for approval as C++17</p>
- <p>This page shows the status of libc++; the status of clang's support of the language features is <a href="http://clang.llvm.org/cxx_status.html#cxx17">here</a>.</p>
+ <p>This page shows the status of libc++; the status of clang's support of the language features is <a href="https://clang.llvm.org/cxx_status.html#cxx17">here</a>.</p>
+
+ <p>Reminder: Features in unreleased drafts of the standard are subject to change.</p>
<p>The groups that have contributed papers:
<ul>
@@ -51,116 +53,119 @@
<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><a href="https://wg21.link/n3346">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<T[]></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>In progress</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>
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4259">N4259</a></td><td>CWG</td></td><td>Wording for std::uncaught_exceptions</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/n4277">N4277</a></td><td>LWG</td></td><td>TriviallyCopyable <code>reference_wrapper</code>.</td><td>Urbana</td><td>Complete</td><td>3.2</td></tr>
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4279">N4279</a></td><td>LWG</td></td><td>Improved insertion interface for unique-key maps.</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/n4280">N4280</a></td><td>LWG</td></td><td>Non-member size() and more</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/n4284">N4284</a></td><td>LWG</td></td><td>Contiguous Iterators.</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/n4285">N4285</a></td><td>CWG</td></td><td>Cleanup for exception-specification and throw-expression.</td><td>Urbana</td><td>Complete</td><td>4.0</td></tr>
+ <tr><td><a href="https://wg21.link/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="https://wg21.link/n4089">N4089</a></td><td>LWG</td></td><td>Safe conversions in <code>unique_ptr<T[]></code>.</td><td>Urbana</td><td>In progress</td><td>3.9</td></tr>
+ <tr><td><a href="https://wg21.link/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="https://wg21.link/n4190">N4190</a></td></td><td>LWG</td><td>Removing auto_ptr, random_shuffle(), And Old <functional> Stuff.</td><td>Urbana</td><td>In progress</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/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>
+ <tr><td><a href="https://wg21.link/n4259">N4259</a></td><td>CWG</td></td><td>Wording for std::uncaught_exceptions</td><td>Urbana</td><td>Complete</td><td>3.7</td></tr>
+ <tr><td><a href="https://wg21.link/n4277">N4277</a></td><td>LWG</td></td><td>TriviallyCopyable <code>reference_wrapper</code>.</td><td>Urbana</td><td>Complete</td><td>3.2</td></tr>
+ <tr><td><a href="https://wg21.link/n4279">N4279</a></td><td>LWG</td></td><td>Improved insertion interface for unique-key maps.</td><td>Urbana</td><td>Complete</td><td>3.7</td></tr>
+ <tr><td><a href="https://wg21.link/n4280">N4280</a></td><td>LWG</td></td><td>Non-member size() and more</td><td>Urbana</td><td>Complete</td><td>3.6</td></tr>
+ <tr><td><a href="https://wg21.link/n4284">N4284</a></td><td>LWG</td></td><td>Contiguous Iterators.</td><td>Urbana</td><td>Complete</td><td>3.6</td></tr>
+ <tr><td><a href="https://wg21.link/n4285">N4285</a></td><td>CWG</td></td><td>Cleanup for exception-specification and throw-expression.</td><td>Urbana</td><td>Complete</td><td>4.0</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/n4387">N4387</a></td><td>LWG</td></td><td>improving pair and tuple</td><td>Lenexa</td><td>Complete</td><td>4.0</td></tr>
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4389">N4389</a></td><td>LWG</td></td><td>bool_constant</td><td>Lenexa</td><td>Complete</td><td>3.7</td></tr>
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4508">N4508</a></td><td>LWG</td></td><td>shared_mutex for C++17</td><td>Lenexa</td><td>Complete</td><td>3.7</td></tr>
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4366">N4366</a></td><td>LWG</td></td><td>LWG 2228 missing SFINAE rule</td><td>Lenexa</td><td>Complete</td><td>3.1</td></tr>
- <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><a href="https://wg21.link/n4387">N4387</a></td><td>LWG</td></td><td>improving pair and tuple</td><td>Lenexa</td><td>Complete</td><td>4.0</td></tr>
+ <tr><td><a href="https://wg21.link/n4389">N4389</a></td><td>LWG</td></td><td>bool_constant</td><td>Lenexa</td><td>Complete</td><td>3.7</td></tr>
+ <tr><td><a href="https://wg21.link/n4508">N4508</a></td><td>LWG</td></td><td>shared_mutex for C++17</td><td>Lenexa</td><td>Complete</td><td>3.7</td></tr>
+ <tr><td><a href="https://wg21.link/n4366">N4366</a></td><td>LWG</td></td><td>LWG 2228 missing SFINAE rule</td><td>Lenexa</td><td>Complete</td><td>3.1</td></tr>
+ <tr><td><a href="https://wg21.link/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/p0092r1.html">P0092R1</a></td><td>LWG</td><td>Polishing <chrono></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.html" >P0156R0</a></td><td>LWG</td><td>Variadic lock_guard(rev 3).</td><td>Kona</td><td><I>Reverted in Kona</I></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><a href="https://wg21.link/p0004r1">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="https://wg21.link/p0006r0">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="https://wg21.link/p0092r1">P0092R1</a></td><td>LWG</td><td>Polishing <chrono></td><td>Kona</td><td>Complete</td><td>3.8</td></tr>
+ <tr><td><a href="https://wg21.link/p0007r1">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="https://wg21.link/p0156r0">P0156R0</a></td><td>LWG</td><td>Variadic lock_guard(rev 3).</td><td>Kona</td><td><I>Reverted in Kona</I></td><td>3.9</td></tr>
+ <tr><td><a href="https://wg21.link/p0074r0">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="https://wg21.link/p0013r1">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>In Progress</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>In Progress</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>Complete</td><td>4.0</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><a href="https://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="https://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="https://wg21.link/P0220R1">P0220R1</a></td><td>LWG</td><td>Adopt Library Fundamentals V1 TS Components for C++17</td><td>Jacksonville</td><td>In Progress</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/P0218R1">P0218R1</a></td><td>LWG</td><td>Adopt the File System TS for C++17</td><td>Jacksonville</td><td>In Progress</td><td></td></tr>
+ <tr><td><a href="https://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="https://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="https://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="https://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="https://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="https://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="https://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="https://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="https://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>Complete</td><td>4.0</td></tr>
+ <tr><td><a href="https://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="https://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>Complete</td><td>4.0</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>Complete</td><td>4.0</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><i>Nothing to do</i></td><td>n/a</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>Now <a href="http://wg21.link/P0067R5">P0067R5</a></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>Complete</td><td>4.0</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>Complete</td><td>4.0</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><i>Nothing to do</i></td><td>n/a</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><i>Removed in Kona</i></td><td>n/a</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>Complete</td><td>4.0</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>Complete</td><td>4.0</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>Complete</td><td>4.0</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>Complete</td><td>4.0</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>Complete</td><td>3.9</td></tr>
- <tr><td><a href="http://wg21.link/p0346r1">p0346r1</a></td><td>LWG</td><td>A <random> Nomenclature Tweak</td><td>Oulu</td><td>Complete</td><td>3.9</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>Complete</td><td>3.9</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><i>Nothing to do</i></td><td>n/a</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>Complete</td><td>4.0</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>Complete</td><td>4.0</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><a href="https://wg21.link/p0032r3">p0032r3</a></td><td>LWG</td><td>Homogeneous interface for variant, any and optional</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
+ <tr><td><a href="https://wg21.link/p0040r3">p0040r3</a></td><td>LWG</td><td>Extending memory management tools</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
+ <tr><td><a href="https://wg21.link/p0063r3">p0063r3</a></td><td>LWG</td><td>C++17 should refer to C11 instead of C99</td><td>Oulu</td><td><i>Nothing to do</i></td><td>n/a</td></tr>
+ <tr><td><a href="https://wg21.link/p0067r3">p0067r3</a></td><td>LWG</td><td>Elementary string conversions</td><td>Oulu</td><td>Now <a href="https://wg21.link/P0067R5">P0067R5</a></td><td></td></tr>
+ <tr><td><a href="https://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="https://wg21.link/p0084r2">p0084r2</a></td><td>LWG</td><td>Emplace Return Type</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
+ <tr><td><a href="https://wg21.link/p0088r3">p0088r3</a></td><td>LWG</td><td>Variant: a type-safe union for C++17</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
+ <tr><td><a href="https://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="https://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="https://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="https://wg21.link/p0180r2">p0180r2</a></td><td>LWG</td><td>Reserve a New Library Namespace for Future Standardization</td><td>Oulu</td><td><i>Nothing to do</i></td><td>n/a</td></tr>
+ <tr><td><a href="https://wg21.link/p0181r1">p0181r1</a></td><td>LWG</td><td>Ordered by Default</td><td>Oulu</td><td><i>Removed in Kona</i></td><td>n/a</td></tr>
+ <tr><td><a href="https://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="https://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="https://wg21.link/p0254r2">p0254r2</a></td><td>LWG</td><td>Integrating std::string_view and std::string</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
+ <tr><td><a href="https://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="https://wg21.link/p0295r0">p0295r0</a></td><td>LWG</td><td>Adopt Selected Library Fundamentals V2 Components for C++17</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
+ <tr><td><a href="https://wg21.link/p0302r1">p0302r1</a></td><td>LWG</td><td>Removing Allocator Support in std::function</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
+ <tr><td><a href="https://wg21.link/p0307r2">p0307r2</a></td><td>LWG</td><td>Making Optional Greater Equal Again</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
+ <tr><td><a href="https://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="https://wg21.link/p0337r0">p0337r0</a></td><td>LWG</td><td>Delete operator= for polymorphic_allocator</td><td>Oulu</td><td>Complete</td><td>3.9</td></tr>
+ <tr><td><a href="https://wg21.link/p0346r1">p0346r1</a></td><td>LWG</td><td>A <random> Nomenclature Tweak</td><td>Oulu</td><td>Complete</td><td>3.9</td></tr>
+ <tr><td><a href="https://wg21.link/p0358r1">p0358r1</a></td><td>LWG</td><td>Fixes for not_fn</td><td>Oulu</td><td>Complete</td><td>3.9</td></tr>
+ <tr><td><a href="https://wg21.link/p0371r1">p0371r1</a></td><td>LWG</td><td>Temporarily discourage memory_order_consume</td><td>Oulu</td><td><i>Nothing to do</i></td><td>n/a</td></tr>
+ <tr><td><a href="https://wg21.link/p0392r0">p0392r0</a></td><td>LWG</td><td>Adapting string_view by filesystem paths</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
+ <tr><td><a href="https://wg21.link/p0393r3">p0393r3</a></td><td>LWG</td><td>Making Variant Greater Equal</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
+ <tr><td><a href="https://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>
- <tr><td><a href="http://wg21.link/P0003R5">P0003R5</a></td><td>LWG</td><td>Removing Deprecated Exception Specifications from C++17</td><td>Issaquah</td><td>Complete</td><td>5.0</td></tr>
- <tr><td><a href="http://wg21.link/P0067R5">P0067R5</a></td><td>LWG</td><td>Elementary string conversions, revision 5</td><td>Issaquah</td><td></td><td></td></tr>
- <tr><td><a href="http://wg21.link/P0403R1">P0403R1</a></td><td>LWG</td><td>Literal suffixes for <tt>basic_string_view</tt></td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
- <tr><td><a href="http://wg21.link/P0414R2">P0414R2</a></td><td>LWG</td><td>Merging shared_ptr changes from Library Fundamentals to C++17</td><td>Issaquah</td><td></td><td></td></tr>
- <tr><td><a href="http://wg21.link/P0418R2">P0418R2</a></td><td>LWG</td><td>Fail or succeed: there is no atomic lattice</td><td>Issaquah</td><td></td><td></td></tr>
- <tr><td><a href="http://wg21.link/P0426R1">P0426R1</a></td><td>LWG</td><td>Constexpr for <tt>std::char_traits</tt></td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
- <tr><td><a href="http://wg21.link/P0435R1">P0435R1</a></td><td>LWG</td><td>Resolving LWG Issues re <tt>common_type</tt></td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
- <tr><td><a href="http://wg21.link/P0502R0">P0502R0</a></td><td>LWG</td><td>Throwing out of a parallel algorithm terminates - but how?</td><td>Issaquah</td><td></td><td></td></tr>
- <tr><td><a href="http://wg21.link/P0503R0">P0503R0</a></td><td>LWG</td><td>Correcting library usage of "literal type"</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
- <tr><td><a href="http://wg21.link/P0504R0">P0504R0</a></td><td>LWG</td><td>Revisiting in-place tag types for any/optional/variant</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
- <tr><td><a href="http://wg21.link/P0505R0">P0505R0</a></td><td>LWG</td><td>Wording for GB 50 - constexpr for chrono</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
- <tr><td><a href="http://wg21.link/P0508R0">P0508R0</a></td><td>LWG</td><td>Wording for GB 58 - structured bindings for node_handles</td><td>Issaquah</td><td></td><td></td></tr>
- <tr><td><a href="http://wg21.link/P0509R1">P0509R1</a></td><td>LWG</td><td>Updating “Restrictions on exception handling”</td><td>Issaquah</td><td><i>Nothing to do</i></td><td>n/a</td></tr>
- <tr><td><a href="http://wg21.link/P0510R0">P0510R0</a></td><td>LWG</td><td>Disallowing references, incomplete types, arrays, and empty variants</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
- <tr><td><a href="http://wg21.link/P0513R0">P0513R0</a></td><td>LWG</td><td>Poisoning the Hash</td><td>Issaquah</td><td>Complete</td><td>5.0</td></tr>
- <tr><td><a href="http://wg21.link/P0516R0">P0516R0</a></td><td>LWG</td><td>Clarify That shared_future’s Copy Operations have Wide Contracts</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
- <tr><td><a href="http://wg21.link/P0517R0">P0517R0</a></td><td>LWG</td><td>Make future_error Constructible</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
- <tr><td><a href="http://wg21.link/P0521R0">P0521R0</a></td><td>LWG</td><td>Proposed Resolution for CA 14 (shared_ptr use_count/unique)</td><td>Issaquah</td><td><i>Nothing to do</i></td><td>n/a</td></tr>
+ <tr><td><a href="https://wg21.link/P0003R5">P0003R5</a></td><td>LWG</td><td>Removing Deprecated Exception Specifications from C++17</td><td>Issaquah</td><td>Complete</td><td>5.0</td></tr>
+ <tr><td><a href="https://wg21.link/P0067R5">P0067R5</a></td><td>LWG</td><td>Elementary string conversions, revision 5</td><td>Issaquah</td><td></td><td></td></tr>
+ <tr><td><a href="https://wg21.link/P0403R1">P0403R1</a></td><td>LWG</td><td>Literal suffixes for <tt>basic_string_view</tt></td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
+ <tr><td><a href="https://wg21.link/P0414R2">P0414R2</a></td><td>LWG</td><td>Merging shared_ptr changes from Library Fundamentals to C++17</td><td>Issaquah</td><td></td><td></td></tr>
+ <tr><td><a href="https://wg21.link/P0418R2">P0418R2</a></td><td>LWG</td><td>Fail or succeed: there is no atomic lattice</td><td>Issaquah</td><td></td><td></td></tr>
+ <tr><td><a href="https://wg21.link/P0426R1">P0426R1</a></td><td>LWG</td><td>Constexpr for <tt>std::char_traits</tt></td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
+ <tr><td><a href="https://wg21.link/P0435R1">P0435R1</a></td><td>LWG</td><td>Resolving LWG Issues re <tt>common_type</tt></td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
+ <tr><td><a href="https://wg21.link/P0502R0">P0502R0</a></td><td>LWG</td><td>Throwing out of a parallel algorithm terminates - but how?</td><td>Issaquah</td><td></td><td></td></tr>
+ <tr><td><a href="https://wg21.link/P0503R0">P0503R0</a></td><td>LWG</td><td>Correcting library usage of "literal type"</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
+ <tr><td><a href="https://wg21.link/P0504R0">P0504R0</a></td><td>LWG</td><td>Revisiting in-place tag types for any/optional/variant</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
+ <tr><td><a href="https://wg21.link/P0505R0">P0505R0</a></td><td>LWG</td><td>Wording for GB 50 - constexpr for chrono</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
+ <tr><td><a href="https://wg21.link/P0508R0">P0508R0</a></td><td>LWG</td><td>Wording for GB 58 - structured bindings for node_handles</td><td>Issaquah</td><td></td><td></td></tr>
+ <tr><td><a href="https://wg21.link/P0509R1">P0509R1</a></td><td>LWG</td><td>Updating “Restrictions on exception handling”</td><td>Issaquah</td><td><i>Nothing to do</i></td><td>n/a</td></tr>
+ <tr><td><a href="https://wg21.link/P0510R0">P0510R0</a></td><td>LWG</td><td>Disallowing references, incomplete types, arrays, and empty variants</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
+ <tr><td><a href="https://wg21.link/P0513R0">P0513R0</a></td><td>LWG</td><td>Poisoning the Hash</td><td>Issaquah</td><td>Complete</td><td>5.0</td></tr>
+ <tr><td><a href="https://wg21.link/P0516R0">P0516R0</a></td><td>LWG</td><td>Clarify That shared_future’s Copy Operations have Wide Contracts</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
+ <tr><td><a href="https://wg21.link/P0517R0">P0517R0</a></td><td>LWG</td><td>Make future_error Constructible</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
+ <tr><td><a href="https://wg21.link/P0521R0">P0521R0</a></td><td>LWG</td><td>Proposed Resolution for CA 14 (shared_ptr use_count/unique)</td><td>Issaquah</td><td><i>Nothing to do</i></td><td>n/a</td></tr>
<tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
- <tr><td><a href="http://wg21.link/P0156R2">P0156R2</a></td><td>LWG</td><td>Variadic Lock guard(rev 5)</td><td>Kona</td><td>Complete</td><td>5.0</td></tr>
- <tr><td><a href="http://wg21.link/P0270R3">P0270R3</a></td><td>CWG</td><td>Removing C dependencies from signal handler wording</td><td>Kona</td><td></td><td></td></tr>
- <tr><td><a href="http://wg21.link/P0298R3">P0298R3</a></td><td>CWG</td><td>A byte type definition</td><td>Kona</td><td>Complete</td><td>5.0</td></tr>
- <tr><td><a href="http://wg21.link/P0317R1">P0317R1</a></td><td>LWG</td><td>Directory Entry Caching for Filesystem</td><td>Kona</td><td></td><td></td></tr>
- <tr><td><a href="http://wg21.link/P0430R2">P0430R2</a></td><td>LWG</td><td>File system library on non-POSIX-like operating systems</td><td>Kona</td><td></td><td></td></tr>
- <tr><td><a href="http://wg21.link/P0433R2">P0433R2</a></td><td>LWG</td><td>Toward a resolution of US7 and US14: Integrating template deduction for class templates into the standard library</td><td>Kona</td><td></td><td></td></tr>
- <tr><td><a href="http://wg21.link/P0452R1">P0452R1</a></td><td>LWG</td><td>Unifying <numeric> Parallel Algorithms</td><td>Kona</td><td></td><td></td></tr>
- <tr><td><a href="http://wg21.link/P0467R2">P0467R2</a></td><td>LWG</td><td>Iterator Concerns for Parallel Algorithms</td><td>Kona</td><td></td><td></td></tr>
- <tr><td><a href="http://wg21.link/P0492R2">P0492R2</a></td><td>LWG</td><td>Proposed Resolution of C++17 National Body Comments for Filesystems</td><td>Kona</td><td></td><td></td></tr>
- <tr><td><a href="http://wg21.link/P0518R1">P0518R1</a></td><td>LWG</td><td>Allowing copies as arguments to function objects given to parallel algorithms in response to CH11</td><td>Kona</td><td></td><td></td></tr>
- <tr><td><a href="http://wg21.link/P0523R1">P0523R1</a></td><td>LWG</td><td>Wording for CH 10: Complexity of parallel algorithms</td><td>Kona</td><td></td><td></td></tr>
- <tr><td><a href="http://wg21.link/P0548R1">P0548R1</a></td><td>LWG</td><td>common_type and duration</td><td>Kona</td><td>Complete</td><td>5.0</td></tr>
- <tr><td><a href="http://wg21.link/P0558R1">P0558R1</a></td><td>LWG</td><td>Resolving atomic<T> named base class inconsistencies</td><td>Kona</td><td></td><td></td></tr>
- <tr><td><a href="http://wg21.link/P0574R1">P0574R1</a></td><td>LWG</td><td>Algorithm Complexity Constraints and Parallel Overloads</td><td>Kona</td><td></td><td></td></tr>
- <tr><td><a href="http://wg21.link/P0599R1">P0599R1</a></td><td>LWG</td><td>noexcept for hash functions</td><td>Kona</td><td>Complete</td><td>5.0</td></tr>
- <tr><td><a href="http://wg21.link/P0604R0">P0604R0</a></td><td>LWG</td><td>Resolving GB 55, US 84, US 85, US 86</td><td>Kona</td><td></td><td></td></tr>
- <tr><td><a href="http://wg21.link/P0607R0">P0607R0</a></td><td>LWG</td><td>Inline Variables for the Standard Library</td><td>Kona</td><td></td><td></td></tr>
- <tr><td><a href="http://wg21.link/P0618R0">P0618R0</a></td><td>LWG</td><td>Deprecating <codecvt></td><td>Kona</td><td></td><td></td></tr>
- <tr><td><a href="http://wg21.link/P0623R0">P0623R0</a></td><td>LWG</td><td>Final C++17 Parallel Algorithms Fixes</td><td>Kona</td><td></td><td></td></tr>
+ <tr><td><a href="https://wg21.link/P0156R2">P0156R2</a></td><td>LWG</td><td>Variadic Lock guard(rev 5)</td><td>Kona</td><td>Complete</td><td>5.0</td></tr>
+ <tr><td><a href="https://wg21.link/P0270R3">P0270R3</a></td><td>CWG</td><td>Removing C dependencies from signal handler wording</td><td>Kona</td><td></td><td></td></tr>
+ <tr><td><a href="https://wg21.link/P0298R3">P0298R3</a></td><td>CWG</td><td>A byte type definition</td><td>Kona</td><td>Complete</td><td>5.0</td></tr>
+ <tr><td><a href="https://wg21.link/P0317R1">P0317R1</a></td><td>LWG</td><td>Directory Entry Caching for Filesystem</td><td>Kona</td><td></td><td></td></tr>
+ <tr><td><a href="https://wg21.link/P0430R2">P0430R2</a></td><td>LWG</td><td>File system library on non-POSIX-like operating systems</td><td>Kona</td><td></td><td></td></tr>
+ <tr><td><a href="https://wg21.link/P0433R2">P0433R2</a></td><td>LWG</td><td>Toward a resolution of US7 and US14: Integrating template deduction for class templates into the standard library</td><td>Kona</td><td></td><td></td></tr>
+ <tr><td><a href="https://wg21.link/P0452R1">P0452R1</a></td><td>LWG</td><td>Unifying <numeric> Parallel Algorithms</td><td>Kona</td><td></td><td></td></tr>
+ <tr><td><a href="https://wg21.link/P0467R2">P0467R2</a></td><td>LWG</td><td>Iterator Concerns for Parallel Algorithms</td><td>Kona</td><td></td><td></td></tr>
+ <tr><td><a href="https://wg21.link/P0492R2">P0492R2</a></td><td>LWG</td><td>Proposed Resolution of C++17 National Body Comments for Filesystems</td><td>Kona</td><td></td><td></td></tr>
+ <tr><td><a href="https://wg21.link/P0518R1">P0518R1</a></td><td>LWG</td><td>Allowing copies as arguments to function objects given to parallel algorithms in response to CH11</td><td>Kona</td><td></td><td></td></tr>
+ <tr><td><a href="https://wg21.link/P0523R1">P0523R1</a></td><td>LWG</td><td>Wording for CH 10: Complexity of parallel algorithms</td><td>Kona</td><td></td><td></td></tr>
+ <tr><td><a href="https://wg21.link/P0548R1">P0548R1</a></td><td>LWG</td><td>common_type and duration</td><td>Kona</td><td>Complete</td><td>5.0</td></tr>
+ <tr><td><a href="https://wg21.link/P0558R1">P0558R1</a></td><td>LWG</td><td>Resolving atomic<T> named base class inconsistencies</td><td>Kona</td><td></td><td></td></tr>
+ <tr><td><a href="https://wg21.link/P0574R1">P0574R1</a></td><td>LWG</td><td>Algorithm Complexity Constraints and Parallel Overloads</td><td>Kona</td><td></td><td></td></tr>
+ <tr><td><a href="https://wg21.link/P0599R1">P0599R1</a></td><td>LWG</td><td>noexcept for hash functions</td><td>Kona</td><td>Complete</td><td>5.0</td></tr>
+ <tr><td><a href="https://wg21.link/P0604R0">P0604R0</a></td><td>LWG</td><td>Resolving GB 55, US 84, US 85, US 86</td><td>Kona</td><td></td><td></td></tr>
+ <tr><td><a href="https://wg21.link/P0607R0">P0607R0</a></td><td>LWG</td><td>Inline Variables for the Standard Library</td><td>Kona</td><td></td><td></td></tr>
+ <tr><td><a href="https://wg21.link/P0618R0">P0618R0</a></td><td>LWG</td><td>Deprecating <codecvt></td><td>Kona</td><td></td><td></td></tr>
+ <tr><td><a href="https://wg21.link/P0623R0">P0623R0</a></td><td>LWG</td><td>Final C++17 Parallel Algorithms Fixes</td><td>Kona</td><td></td><td></td></tr>
+ <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
+ <tr><td><a href="https://wg21.link/P0682R1">P0682R1</a></td><td>LWG</td><td>Repairing elementary string conversions</td><td>Toronto</td><td></td><td></td></tr>
+ <tr><td><a href="https://wg21.link/P0739R0">P0739R0</a></td><td>LWG</td><td>Some improvements to class template argument deduction integration into the standard library</td><td>Toronto</td><td>Complete</td><td>5.0</td></tr>
<!-- <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr> -->
</table>
@@ -171,325 +176,330 @@
<!-- <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://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>Complete</td></tr>
+ <tr><td><a href="https://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="https://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="https://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="https://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="https://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="https://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="https://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="https://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="https://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="https://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="https://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="https://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="https://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>Complete</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><a href="https://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="https://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="https://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="https://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="https://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="https://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="https://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="https://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="https://wg21.link/LWG2361">2361</td><td>Apply 2299 resolution throughout library</td><td>Urbana</td><td>Complete</td></tr>
+ <tr><td><a href="https://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="https://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="https://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><a href="https://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="https://wg21.link/LWG2063">2063</td><td>Contradictory requirements for string move assignment</td><td>Lenexa</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2076">2076</td><td>Bad CopyConstructible requirement in set constructors</td><td>Lenexa</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2160">2160</td><td>Unintended destruction ordering-specification of resize</td><td>Lenexa</td><td>Complete</td></tr>
+ <tr><td><a href="https://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="https://wg21.link/LWG2239">2239</td><td>min/max/minmax requirements</td><td>Lenexa</td><td>Complete</td></tr>
+ <tr><td><a href="https://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="https://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="https://wg21.link/LWG2378">2378</td><td>Behaviour of standard exception types</td><td>Lenexa</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2403">2403</td><td>stof() should call strtof() and wcstof()</td><td>Lenexa</td><td>Complete</td></tr>
+ <tr><td><a href="https://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="https://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="https://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="https://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="https://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="https://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="https://wg21.link/LWG2427">2427</td><td>Container adaptors as sequence containers, redux</td><td>Lenexa</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2428">2428</td><td>"External declaration" used without being defined</td><td>Lenexa</td><td>Complete</td></tr>
+ <tr><td><a href="https://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="https://wg21.link/LWG2434">2434</td><td>shared_ptr::use_count() is efficient</td><td>Lenexa</td><td>Complete</td></tr>
+ <tr><td><a href="https://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="https://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="https://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="https://wg21.link/LWG2440">2440</td><td>seed_seq::size() should be noexcept</td><td>Lenexa</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2442">2442</td><td>call_once() shouldn't DECAY_COPY()</td><td>Lenexa</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2448">2448</td><td>Non-normative Container destructor specification</td><td>Lenexa</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2454">2454</td><td>Add raw_storage_iterator::base() member</td><td>Lenexa</td><td>Complete</td></tr>
+ <tr><td><a href="https://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="https://wg21.link/LWG2458">2458</td><td>N3778 and new library deallocation signatures</td><td>Lenexa</td><td>Complete</td></tr>
+ <tr><td><a href="https://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="https://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="https://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="https://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="https://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="https://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://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>/<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><cstdlib></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&&</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><a href="https://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="https://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="https://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="https://wg21.link/LWG2111">2111</a></td><td>Which <tt>unexpected</tt>/<tt>terminate</tt> handler is called from the exception handling runtime?</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://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="https://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="https://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="https://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="https://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="https://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="https://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="https://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="https://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="https://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="https://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="https://wg21.link/LWG2273">2273</a></td><td><tt>regex_match</tt> ambiguity</td><td>Kona</td><td></td></tr>
+ <tr><td><a href="https://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="https://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="https://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="https://wg21.link/LWG2380">2380</a></td><td>May <tt><cstdlib></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="https://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="https://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="https://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="https://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="https://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="https://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="https://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="https://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="https://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="https://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="https://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="https://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="https://wg21.link/LWG2485">2485</a></td><td><tt>get()</tt> should be overloaded for <tt>const tuple&&</tt></td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://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="https://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="https://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="https://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="https://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://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)<void></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<T[]></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>§[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&&)</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><type_traits></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>§[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&)</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><a href="https://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="https://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="https://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="https://wg21.link/LWG2450">2450</a></td><td><tt>(greater|less|greater_equal|less_equal)<void></tt> do not yield a total order for pointers</td><td>Jacksonville</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2520">2520</a></td><td>N4089 broke initializing <tt>unique_ptr<T[]></tt> from a <tt>nullptr</tt></td><td>Jacksonville</td><td>Complete</td></tr>
+ <tr><td><a href="https://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="https://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="https://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="https://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="https://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="https://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="https://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="https://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="https://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="https://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="https://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="https://wg21.link/LWG2571">2571</a></td><td>§[map.modifiers]/2 imposes nonsensical requirement on <tt>insert(InputIterator, InputIterator)</tt></td><td>Jacksonville</td><td>Complete</td></tr>
+ <tr><td><a href="https://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="https://wg21.link/LWG2574">2574</a></td><td>[fund.ts.v2] <tt>std::experimental::function::operator=(F&&)</tt> should be constrained</td><td>Jacksonville</td><td></td></tr>
+ <tr><td><a href="https://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="https://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="https://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="https://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="https://wg21.link/LWG2581">2581</a></td><td>Specialization of <tt><type_traits></tt> variable templates should be prohibited</td><td>Jacksonville</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2582">2582</a></td><td>§[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="https://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="https://wg21.link/LWG2585">2585</a></td><td><tt>forward_list::resize(size_type, const value_type&)</tt> effects incorrect</td><td>Jacksonville</td><td>Complete</td></tr>
+ <tr><td><a href="https://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="https://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://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>Complete</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>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2422">2422</a></td><td>std::numeric_limits<T>::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>Complete</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<std::experimental::shared_ptr> 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>Complete</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>Complete</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>Complete</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>Complete</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="https://wg21.link/LWG2181">2181</a></td><td>Exceptions from seed sequence operations</td><td>Oulu</td><td>Complete</td></tr>
+ <tr><td><a href="https://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="https://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="https://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="https://wg21.link/LWG2328">2328</a></td><td>Rvalue stream extraction should use perfect forwarding</td><td>Oulu</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2393">2393</a></td><td>std::function's Callable definition is broken</td><td>Oulu</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2422">2422</a></td><td>std::numeric_limits<T>::is_modulo description: "most machines" errata</td><td>Oulu</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2426">2426</a></td><td>Issue about compare_exchange</td><td>Oulu</td><td></td></tr>
+ <tr><td><a href="https://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="https://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="https://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="https://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>Complete</td></tr>
+ <tr><td><a href="https://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="https://wg21.link/LWG2542">2542</a></td><td>Missing const requirements for associative containers</td><td>Oulu</td><td></td></tr>
+ <tr><td><a href="https://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="https://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="https://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="https://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="https://wg21.link/LWG2573">2573</a></td><td>[fund.ts.v2] std::hash<std::experimental::shared_ptr> does not work for arrays</td><td>Oulu</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2596">2596</a></td><td>vector::data() should use addressof</td><td>Oulu</td><td>Complete</td></tr>
+ <tr><td><a href="https://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="https://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="https://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="https://wg21.link/LWG2671">2671</a></td><td>Errors in Copy</td><td>Oulu</td><td>Complete</td></tr>
+ <tr><td><a href="https://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="https://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="https://wg21.link/LWG2683">2683</a></td><td>filesystem::copy() says "no effects"</td><td>Oulu</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2684">2684</a></td><td>priority_queue lacking comparator typedef</td><td>Oulu</td><td>Complete</td></tr>
+ <tr><td><a href="https://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="https://wg21.link/LWG2687">2687</a></td><td>{inclusive,exclusive}_scan misspecified</td><td>Oulu</td><td></td></tr>
+ <tr><td><a href="https://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="https://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="https://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="https://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="https://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="https://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="https://wg21.link/LWG2709">2709</a></td><td>offsetof is unnecessarily imprecise</td><td>Oulu</td><td></td></tr>
+ <tr><td><a href="https://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="https://wg21.link/LWG2711">2711</a></td><td>path is convertible from approximately everything under the sun</td><td>Oulu</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2716">2716</a></td><td>Specification of shuffle and sample disallows lvalue URNGs</td><td>Oulu</td><td>Complete</td></tr>
+ <tr><td><a href="https://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="https://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="https://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="https://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="https://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="https://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="https://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="https://wg21.link/LWG2726">2726</a></td><td>[recursive_]directory_iterator::increment(error_code&) is underspecified</td><td>Oulu</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2727">2727</a></td><td>Parallel algorithms with constexpr specifier</td><td>Oulu</td><td></td></tr>
+ <tr><td><a href="https://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></td><td></td><td></td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2062">2062</a></td><td>Effect contradictions w/o no-throw guarantee of std::function swaps</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2166">2166</a></td><td>Heap property underspecified?</td><td>Issaquah</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2221">2221</a></td><td>No formatted output operator for nullptr</td><td>Issaquah</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2223">2223</a></td><td>shrink_to_fit effect on iterator validity</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2261">2261</a></td><td>Are containers required to use their 'pointer' type internally?</td><td>Issaquah</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2394">2394</a></td><td>locale::name specification unclear - what is implementation-defined?</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2460">2460</a></td><td>LWG issue 2408 and value categories</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2468">2468</a></td><td>Self-move-assignment of library types</td><td>Issaquah</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2475">2475</a></td><td>Allow overwriting of std::basic_string terminator with charT() to allow cleaner interoperation with legacy APIs</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2503">2503</a></td><td>multiline option should be added to syntax_option_type</td><td>Issaquah</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2510">2510</a></td><td>Tag types should not be DefaultConstructible</td><td>Issaquah</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2514">2514</a></td><td>Type traits must not be final</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2518">2518</a></td><td>[fund.ts.v2] Non-member swap for propagate_const should call member swap</td><td>Issaquah</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2519">2519</a></td><td>Iterator operator-= has gratuitous undefined behaviour</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2521">2521</a></td><td>[fund.ts.v2] weak_ptr's converting move constructor should be modified as well for array support</td><td>Issaquah</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2525">2525</a></td><td>[fund.ts.v2] get_memory_resource should be const and noexcept</td><td>Issaquah</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2527">2527</a></td><td>[fund.ts.v2] ALLOCATOR_OF for function::operator= has incorrect default</td><td>Issaquah</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2531">2531</a></td><td>future::get should explicitly state that the shared state is released</td><td>Issaquah</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2534">2534</a></td><td>Constrain rvalue stream operators</td><td>Issaquah</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2536">2536</a></td><td>What should <complex.h> do?</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2540">2540</a></td><td>unordered_multimap::insert hint iterator</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2543">2543</a></td><td>LWG 2148 (hash support for enum types) seems under-specified</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2544">2544</a></td><td>istreambuf_iterator(basic_streambuf<charT, traits>* s) effects unclear when s is 0</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2556">2556</a></td><td>Wide contract for future::share()</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2562">2562</a></td><td>Consistent total ordering of pointers by comparison functors</td><td>Issaquah</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2567">2567</a></td><td>Specification of logical operator traits uses BaseCharacteristic, which is defined only for UnaryTypeTraits and BinaryTypeTraits</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2568">2568</a></td><td>[fund.ts.v2] Specification of logical operator traits uses BaseCharacteristic, which is defined only for UnaryTypeTraits and BinaryTypeTraits</td><td>Issaquah</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2569">2569</a></td><td>conjunction and disjunction requirements are too strict</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2570">2570</a></td><td>[fund.ts.v2] conjunction and disjunction requirements are too strict</td><td>Issaquah</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2578">2578</a></td><td>Iterator requirements should reference iterator traits</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2584">2584</a></td><td><regex> ECMAScript IdentityEscape is ambiguous</td><td>Issaquah</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2588">2588</a></td><td>[fund.ts.v2] "Convertible to bool" requirement in conjunction and disjunction</td><td>Issaquah</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2589">2589</a></td><td>match_results can't satisfy the requirements of a container</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2591">2591</a></td><td>std::function's member template target() should not lead to undefined behaviour</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2598">2598</a></td><td>addressof works on temporaries</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2664">2664</a></td><td>operator/ (and other append) semantics not useful if argument has root</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2665">2665</a></td><td>remove_filename() post condition is incorrect</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2672">2672</a></td><td>Should is_empty use error_code in its specification?</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2678">2678</a></td><td>std::filesystem enum classes overspecified</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2679">2679</a></td><td>Inconsistent Use of Effects and Equivalent To</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2680">2680</a></td><td>Add "Equivalent to" to filesystem</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2681">2681</a></td><td>filesystem::copy() cannot copy symlinks</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2682">2682</a></td><td>filesystem::copy() won't create a symlink to a directory</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2686">2686</a></td><td>Why is std::hash specialized for error_code, but not error_condition?</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2694">2694</a></td><td>Application of LWG 436 accidentally deleted definition of "facet"</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2696">2696</a></td><td>Interaction between make_shared and enable_shared_from_this is underspecified</td><td>Issaquah</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2699">2699</a></td><td>Missing restriction in [numeric.requirements]</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2712">2712</a></td><td>copy_file(from, to, ...) has a number of unspecified error conditions</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2722">2722</a></td><td>equivalent incorrectly specifies throws clause</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2729">2729</a></td><td>Missing SFINAE on std::pair::operator=</td><td>Issaquah</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2732">2732</a></td><td>Questionable specification of path::operator/= and path::append</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2733">2733</a></td><td>[fund.ts.v2] gcd / lcm and bool</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2735">2735</a></td><td>std::abs(short), std::abs(signed char) and others should return int instead of double in order to be compatible with C++98 and C</td><td>Issaquah</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2736">2736</a></td><td>nullopt_t insufficiently constrained</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2738">2738</a></td><td>is_constructible with void types</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2739">2739</a></td><td>Issue with time_point non-member subtraction with an unsigned duration</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2740">2740</a></td><td>constexpr optional<T>::operator-></td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2742">2742</a></td><td>Inconsistent string interface taking string_view</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2744">2744</a></td><td>any's in_place constructors</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2745">2745</a></td><td>[fund.ts.v2] Implementability of LWG 2451</td><td>Issaquah</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2747">2747</a></td><td>Possibly redundant std::move in [alg.foreach]</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2748">2748</a></td><td>swappable traits for optionals</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2749">2749</a></td><td>swappable traits for variants</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2750">2750</a></td><td>[fund.ts.v2] LWG 2451 conversion constructor constraint</td><td>Issaquah</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2752">2752</a></td><td>"Throws:" clauses of async and packaged_task are unimplementable</td><td>Issaquah</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2755">2755</a></td><td>[string.view.io] uses non-existent basic_string_view::to_string function</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2756">2756</a></td><td>C++ WP optional<T> should 'forward' T's implicit conversions</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2758">2758</a></td><td>std::string{}.assign("ABCDE", 0, 1) is ambiguous</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2759">2759</a></td><td>gcd / lcm and bool for the WP</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2760">2760</a></td><td>non-const basic_string::data should not invalidate iterators</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2765">2765</a></td><td>Did LWG 1123 go too far?</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2767">2767</a></td><td>not_fn call_wrapper can form invalid types</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2769">2769</a></td><td>Redundant const in the return type of any_cast(const any&)</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2771">2771</a></td><td>Broken Effects of some basic_string::compare functions in terms of basic_string_view</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2773">2773</a></td><td>Making std::ignore constexpr</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2777">2777</a></td><td>basic_string_view::copy should use char_traits::copy</td><td>Issaquah</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2778">2778</a></td><td>basic_string_view is missing constexpr</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2062">2062</a></td><td>Effect contradictions w/o no-throw guarantee of std::function swaps</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2166">2166</a></td><td>Heap property underspecified?</td><td>Issaquah</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2221">2221</a></td><td>No formatted output operator for nullptr</td><td>Issaquah</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2223">2223</a></td><td>shrink_to_fit effect on iterator validity</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2261">2261</a></td><td>Are containers required to use their 'pointer' type internally?</td><td>Issaquah</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2394">2394</a></td><td>locale::name specification unclear - what is implementation-defined?</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2460">2460</a></td><td>LWG issue 2408 and value categories</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2468">2468</a></td><td>Self-move-assignment of library types</td><td>Issaquah</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2475">2475</a></td><td>Allow overwriting of std::basic_string terminator with charT() to allow cleaner interoperation with legacy APIs</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2503">2503</a></td><td>multiline option should be added to syntax_option_type</td><td>Issaquah</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2510">2510</a></td><td>Tag types should not be DefaultConstructible</td><td>Issaquah</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2514">2514</a></td><td>Type traits must not be final</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2518">2518</a></td><td>[fund.ts.v2] Non-member swap for propagate_const should call member swap</td><td>Issaquah</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2519">2519</a></td><td>Iterator operator-= has gratuitous undefined behaviour</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2521">2521</a></td><td>[fund.ts.v2] weak_ptr's converting move constructor should be modified as well for array support</td><td>Issaquah</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2525">2525</a></td><td>[fund.ts.v2] get_memory_resource should be const and noexcept</td><td>Issaquah</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2527">2527</a></td><td>[fund.ts.v2] ALLOCATOR_OF for function::operator= has incorrect default</td><td>Issaquah</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2531">2531</a></td><td>future::get should explicitly state that the shared state is released</td><td>Issaquah</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2534">2534</a></td><td>Constrain rvalue stream operators</td><td>Issaquah</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2536">2536</a></td><td>What should <complex.h> do?</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2540">2540</a></td><td>unordered_multimap::insert hint iterator</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2543">2543</a></td><td>LWG 2148 (hash support for enum types) seems under-specified</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2544">2544</a></td><td>istreambuf_iterator(basic_streambuf<charT, traits>* s) effects unclear when s is 0</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2556">2556</a></td><td>Wide contract for future::share()</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2562">2562</a></td><td>Consistent total ordering of pointers by comparison functors</td><td>Issaquah</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2567">2567</a></td><td>Specification of logical operator traits uses BaseCharacteristic, which is defined only for UnaryTypeTraits and BinaryTypeTraits</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2568">2568</a></td><td>[fund.ts.v2] Specification of logical operator traits uses BaseCharacteristic, which is defined only for UnaryTypeTraits and BinaryTypeTraits</td><td>Issaquah</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2569">2569</a></td><td>conjunction and disjunction requirements are too strict</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2570">2570</a></td><td>[fund.ts.v2] conjunction and disjunction requirements are too strict</td><td>Issaquah</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2578">2578</a></td><td>Iterator requirements should reference iterator traits</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2584">2584</a></td><td><regex> ECMAScript IdentityEscape is ambiguous</td><td>Issaquah</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2588">2588</a></td><td>[fund.ts.v2] "Convertible to bool" requirement in conjunction and disjunction</td><td>Issaquah</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2589">2589</a></td><td>match_results can't satisfy the requirements of a container</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2591">2591</a></td><td>std::function's member template target() should not lead to undefined behaviour</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2598">2598</a></td><td>addressof works on temporaries</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2664">2664</a></td><td>operator/ (and other append) semantics not useful if argument has root</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2665">2665</a></td><td>remove_filename() post condition is incorrect</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2672">2672</a></td><td>Should is_empty use error_code in its specification?</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2678">2678</a></td><td>std::filesystem enum classes overspecified</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2679">2679</a></td><td>Inconsistent Use of Effects and Equivalent To</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2680">2680</a></td><td>Add "Equivalent to" to filesystem</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2681">2681</a></td><td>filesystem::copy() cannot copy symlinks</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2682">2682</a></td><td>filesystem::copy() won't create a symlink to a directory</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2686">2686</a></td><td>Why is std::hash specialized for error_code, but not error_condition?</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2694">2694</a></td><td>Application of LWG 436 accidentally deleted definition of "facet"</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2696">2696</a></td><td>Interaction between make_shared and enable_shared_from_this is underspecified</td><td>Issaquah</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2699">2699</a></td><td>Missing restriction in [numeric.requirements]</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2712">2712</a></td><td>copy_file(from, to, ...) has a number of unspecified error conditions</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2722">2722</a></td><td>equivalent incorrectly specifies throws clause</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2729">2729</a></td><td>Missing SFINAE on std::pair::operator=</td><td>Issaquah</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2732">2732</a></td><td>Questionable specification of path::operator/= and path::append</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2733">2733</a></td><td>[fund.ts.v2] gcd / lcm and bool</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2735">2735</a></td><td>std::abs(short), std::abs(signed char) and others should return int instead of double in order to be compatible with C++98 and C</td><td>Issaquah</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2736">2736</a></td><td>nullopt_t insufficiently constrained</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2738">2738</a></td><td>is_constructible with void types</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2739">2739</a></td><td>Issue with time_point non-member subtraction with an unsigned duration</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2740">2740</a></td><td>constexpr optional<T>::operator-></td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2742">2742</a></td><td>Inconsistent string interface taking string_view</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2744">2744</a></td><td>any's in_place constructors</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2745">2745</a></td><td>[fund.ts.v2] Implementability of LWG 2451</td><td>Issaquah</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2747">2747</a></td><td>Possibly redundant std::move in [alg.foreach]</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2748">2748</a></td><td>swappable traits for optionals</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2749">2749</a></td><td>swappable traits for variants</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2750">2750</a></td><td>[fund.ts.v2] LWG 2451 conversion constructor constraint</td><td>Issaquah</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2752">2752</a></td><td>"Throws:" clauses of async and packaged_task are unimplementable</td><td>Issaquah</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2755">2755</a></td><td>[string.view.io] uses non-existent basic_string_view::to_string function</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2756">2756</a></td><td>C++ WP optional<T> should 'forward' T's implicit conversions</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2758">2758</a></td><td>std::string{}.assign("ABCDE", 0, 1) is ambiguous</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2759">2759</a></td><td>gcd / lcm and bool for the WP</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2760">2760</a></td><td>non-const basic_string::data should not invalidate iterators</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2765">2765</a></td><td>Did LWG 1123 go too far?</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2767">2767</a></td><td>not_fn call_wrapper can form invalid types</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2769">2769</a></td><td>Redundant const in the return type of any_cast(const any&)</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2771">2771</a></td><td>Broken Effects of some basic_string::compare functions in terms of basic_string_view</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2773">2773</a></td><td>Making std::ignore constexpr</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2777">2777</a></td><td>basic_string_view::copy should use char_traits::copy</td><td>Issaquah</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2778">2778</a></td><td>basic_string_view is missing constexpr</td><td>Issaquah</td><td>Complete</td></tr>
<tr><td></td><td></td><td></td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2260">2260</a></td><td>Missing requirement for Allocator::pointer</td><td>Kona</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2676">2676</a></td><td>Provide filesystem::path overloads for File-based streams</td><td>Kona</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2768">2768</a></td><td>any_cast and move semantics</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2769">2769</a></td><td>Redundant const in the return type of any_cast(const any&)</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2781">2781</a></td><td>Contradictory requirements for std::function and std::reference_wrapper</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2782">2782</a></td><td>scoped_allocator_adaptor constructors must be constrained</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2784">2784</a></td><td>Resolution to LWG 2484 is missing "otherwise, no effects" and is hard to parse</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2785">2785</a></td><td>quoted should work with basic_string_view</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2786">2786</a></td><td>Annex C should mention shared_ptr changes for array support</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2787">2787</a></td><td>§[file_status.cons] doesn't match class definition</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2788">2788</a></td><td>basic_string range mutators unintentionally require a default constructible allocator</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2789">2789</a></td><td>Equivalence of contained objects</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2790">2790</a></td><td>Missing specification of istreambuf_iterator::operator-></td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2794">2794</a></td><td>Missing requirements for allocator pointers</td><td>Kona</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2795">2795</a></td><td>§[global.functions] provides incorrect example of ADL use</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2796">2796</a></td><td>tuple should be a literal type</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2801">2801</a></td><td>Default-constructibility of unique_ptr</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2802">2802</a></td><td>shared_ptr constructor requirements for a deleter</td><td>Kona</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2804">2804</a></td><td>Unconditional constexpr default constructor for istream_iterator</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2806">2806</a></td><td>Base class of bad_optional_access</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2807">2807</a></td><td>std::invoke should use std::is_nothrow_callable</td><td>Kona</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2812">2812</a></td><td>Range access is available with <string_view></td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2824">2824</a></td><td>list::sort should say that the order of elements is unspecified if an exception is thrown</td><td>Kona</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2826">2826</a></td><td>string_view iterators use old wording</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2834">2834</a></td><td>Resolution LWG 2223 is missing wording about end iterators</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2835">2835</a></td><td>LWG 2536 seems to misspecify <tgmath.h></td><td>Kona</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2837">2837</a></td><td>gcd and lcm should support a wider range of input values</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2838">2838</a></td><td>is_literal_type specification needs a little cleanup</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2842">2842</a></td><td>in_place_t check for optional::optional(U&&) should decay U</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2850">2850</a></td><td>std::function move constructor does unnecessary work</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2853">2853</a></td><td>Possible inconsistency in specification of erase in [vector.modifiers]</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2855">2855</a></td><td>std::throw_with_nested("string_literal")</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2857">2857</a></td><td>{variant,optional,any}::emplace should return the constructed value</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2861">2861</a></td><td>basic_string should require that charT match traits::char_type</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2866">2866</a></td><td>Incorrect derived classes constraints</td><td>Kona</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2868">2868</a></td><td>Missing specification of bad_any_cast::what()</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2872">2872</a></td><td>Add definition for direct-non-list-initialization</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2873">2873</a></td><td>Add noexcept to several shared_ptr related functions</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2874">2874</a></td><td>Constructor shared_ptr::shared_ptr(Y*) should be constrained</td><td>Kona</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2875">2875</a></td><td>shared_ptr::shared_ptr(Y*, D, […]) constructors should be constrained</td><td>Kona</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2876">2876</a></td><td>shared_ptr::shared_ptr(const weak_ptr<Y>&) constructor should be constrained</td><td>Kona</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2878">2878</a></td><td>Missing DefaultConstructible requirement for istream_iterator default constructor</td><td>Kona</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2890">2890</a></td><td>The definition of 'object state' applies only to class types</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2900">2900</a></td><td>The copy and move constructors of optional are not constexpr</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2903">2903</a></td><td>The form of initialization for the emplace-constructors is not specified</td><td>Kona</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2904">2904</a></td><td>Make variant move-assignment more exception safe</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2905">2905</a></td><td>is_constructible_v<unique_ptr<P, D>, P, D const &> should be false when D is not copy constructible</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2908">2908</a></td><td>The less-than operator for shared pointers could do more</td><td>Kona</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2911">2911</a></td><td>An is_aggregate type trait is needed</td><td>Kona</td><td>Complete</td></tr>
- <tr><td><a href="http://wg21.link/LWG2921">2921</a></td><td>packaged_task and type-erased allocators</td><td>Kona</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2934">2934</a></td><td>optional<const T> doesn't compare with T</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2260">2260</a></td><td>Missing requirement for Allocator::pointer</td><td>Kona</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2676">2676</a></td><td>Provide filesystem::path overloads for File-based streams</td><td>Kona</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2768">2768</a></td><td>any_cast and move semantics</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2769">2769</a></td><td>Redundant const in the return type of any_cast(const any&)</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2781">2781</a></td><td>Contradictory requirements for std::function and std::reference_wrapper</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2782">2782</a></td><td>scoped_allocator_adaptor constructors must be constrained</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2784">2784</a></td><td>Resolution to LWG 2484 is missing "otherwise, no effects" and is hard to parse</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2785">2785</a></td><td>quoted should work with basic_string_view</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2786">2786</a></td><td>Annex C should mention shared_ptr changes for array support</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2787">2787</a></td><td>§[file_status.cons] doesn't match class definition</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2788">2788</a></td><td>basic_string range mutators unintentionally require a default constructible allocator</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2789">2789</a></td><td>Equivalence of contained objects</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2790">2790</a></td><td>Missing specification of istreambuf_iterator::operator-></td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2794">2794</a></td><td>Missing requirements for allocator pointers</td><td>Kona</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2795">2795</a></td><td>§[global.functions] provides incorrect example of ADL use</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2796">2796</a></td><td>tuple should be a literal type</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2801">2801</a></td><td>Default-constructibility of unique_ptr</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2802">2802</a></td><td>shared_ptr constructor requirements for a deleter</td><td>Kona</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2804">2804</a></td><td>Unconditional constexpr default constructor for istream_iterator</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2806">2806</a></td><td>Base class of bad_optional_access</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2807">2807</a></td><td>std::invoke should use std::is_nothrow_callable</td><td>Kona</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2812">2812</a></td><td>Range access is available with <string_view></td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2824">2824</a></td><td>list::sort should say that the order of elements is unspecified if an exception is thrown</td><td>Kona</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2826">2826</a></td><td>string_view iterators use old wording</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2834">2834</a></td><td>Resolution LWG 2223 is missing wording about end iterators</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2835">2835</a></td><td>LWG 2536 seems to misspecify <tgmath.h></td><td>Kona</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2837">2837</a></td><td>gcd and lcm should support a wider range of input values</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2838">2838</a></td><td>is_literal_type specification needs a little cleanup</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2842">2842</a></td><td>in_place_t check for optional::optional(U&&) should decay U</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2850">2850</a></td><td>std::function move constructor does unnecessary work</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2853">2853</a></td><td>Possible inconsistency in specification of erase in [vector.modifiers]</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2855">2855</a></td><td>std::throw_with_nested("string_literal")</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2857">2857</a></td><td>{variant,optional,any}::emplace should return the constructed value</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2861">2861</a></td><td>basic_string should require that charT match traits::char_type</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2866">2866</a></td><td>Incorrect derived classes constraints</td><td>Kona</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2868">2868</a></td><td>Missing specification of bad_any_cast::what()</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2872">2872</a></td><td>Add definition for direct-non-list-initialization</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2873">2873</a></td><td>Add noexcept to several shared_ptr related functions</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2874">2874</a></td><td>Constructor shared_ptr::shared_ptr(Y*) should be constrained</td><td>Kona</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2875">2875</a></td><td>shared_ptr::shared_ptr(Y*, D, […]) constructors should be constrained</td><td>Kona</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2876">2876</a></td><td>shared_ptr::shared_ptr(const weak_ptr<Y>&) constructor should be constrained</td><td>Kona</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2878">2878</a></td><td>Missing DefaultConstructible requirement for istream_iterator default constructor</td><td>Kona</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2890">2890</a></td><td>The definition of 'object state' applies only to class types</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2900">2900</a></td><td>The copy and move constructors of optional are not constexpr</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2903">2903</a></td><td>The form of initialization for the emplace-constructors is not specified</td><td>Kona</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2904">2904</a></td><td>Make variant move-assignment more exception safe</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2905">2905</a></td><td>is_constructible_v<unique_ptr<P, D>, P, D const &> should be false when D is not copy constructible</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2908">2908</a></td><td>The less-than operator for shared pointers could do more</td><td>Kona</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2911">2911</a></td><td>An is_aggregate type trait is needed</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2921">2921</a></td><td>packaged_task and type-erased allocators</td><td>Kona</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2934">2934</a></td><td>optional<const T> doesn't compare with T</td><td>Kona</td><td>Complete</td></tr>
+ <tr><td></td><td></td><td></td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2901">2901</a></td><td>Variants cannot properly support allocators</td><td>Toronto</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2955">2955</a></td><td><tt>to_chars / from_chars</tt> depend on <tt>std::string</tt></td><td>Toronto</td><td>Resolved by <a href="https://wg21.link/P0682R1">P0682R1</a></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2956">2956</a></td><td><tt>filesystem::canonical()</tt> still defined in terms of <tt>absolute(p, base)</tt></td><td>Toronto</td><td>Complete</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><a href="https://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: 25-May-2017</p>
+ <p>Last Updated: 27-Jul-2017</p>
</div>
</body>
</html>
diff --git a/www/cxx2a_status.html b/www/cxx2a_status.html
new file mode 100644
index 0000000..e6e50ae
--- /dev/null
+++ b/www/cxx2a_status.html
@@ -0,0 +1,92 @@
+<!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=utf-8">
+ <title>libc++ C++2a 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="https://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="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
+ <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
+ <a href="https://bugs.llvm.org/">Bug Reports</a>
+ <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
+ <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+ </div>
+</div>
+
+<div id="content">
+ <!--*********************************************************************-->
+ <h1>libc++ C++2a Status</h1>
+ <!--*********************************************************************-->
+
+ <p>In July 2017, the C++ standard committee created a draft for the next version of the C++ standard, known here as "C++2a" (probably to be C++20).</p>
+ <p>This page shows the status of libc++; the status of clang's support of the language features is <a href="https://clang.llvm.org/cxx_status.html#cxx2a">here</a>.</p>
+
+ <p>Reminder: Features in unreleased drafts of the standard are subject to change.</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="https://wg21.link/n3346">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="https://wg21.link/P0463R1">P0463R1</a></td><td>LWG</td><td>Endian just Endian</td><td>Toronto</td><td></td><td></td></tr>
+ <tr><td><a href="https://wg21.link/P0674R1">P0674R1</a></td><td>LWG</td><td>Extending make_shared to Support Arrays</td><td>Toronto</td><td></td><td></td></tr>
+
+<!-- <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr> -->
+ </table>
+
+<p><i>[ Note: "Nothing to do" means that no library changes were needed to implement this change -- end note]</i></p>
+
+ <h3>Library Working group Issues Status</h3>
+<!-- <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="https://wg21.link/LWG1214">1214</a></td><td>Insufficient/inconsistent key immutability requirements for associative containers</td><td>Urbana</td><td></td></tr>
+-->
+ <tr><td><a href="https://wg21.link/LWG2070">2070</a></td><td><tt>allocate_shared</tt> should use <tt>allocator_traits<A>::construct</tt></td><td>Toronto</td><td>Resolved by <a href="https://wg21.link/P0674R1">P0674R1</a></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2444">2444</a></td><td>Inconsistent complexity for <tt>std::sort_heap</tt></td><td>Toronto</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2593">2593</a></td><td>Moved-from state of Allocators</td><td>Toronto</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2597">2597</a></td><td><tt>std::log</tt> misspecified for complex numbers</td><td>Toronto</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2783">2783</a></td><td><tt>stack::emplace()</tt> and <tt>queue::emplace()</tt> should return <tt>decltype(auto)</tt></td><td>Toronto</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2932">2932</a></td><td>Constraints on parallel algorithm implementations are underspecified</td><td>Toronto</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2937">2937</a></td><td>Is <tt>equivalent("existing_thing", "not_existing_thing")</tt> an error</td><td>Toronto</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2940">2940</a></td><td><tt>result_of</tt> specification also needs a little cleanup</td><td>Toronto</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2942">2942</a></td><td>LWG 2873's resolution missed <tt>weak_ptr::owner_before</tt></td><td>Toronto</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2954">2954</a></td><td>Specialization of the convenience variable templates should be prohibited</td><td>Toronto</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2961">2961</a></td><td>Bad postcondition for <tt>set_default_resource</tt></td><td>Toronto</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2966">2966</a></td><td>Incomplete resolution of US 74</td><td>Toronto</td><td><i>Nothing to do</i></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2974">2974</a></td><td>Diagnose out of bounds <tt>tuple_element/variant_alternative</tt></td><td>Toronto</td><td>Complete</td></tr>
+
+<!-- <tr><td></td><td></td><td></td><td></td></tr> -->
+ </table>
+
+ <p>Last Updated: 16-Jul-2017</p>
+</div>
+</body>
+</html>
diff --git a/www/index.html b/www/index.html
index 5dc1385..eca48ce 100644
--- a/www/index.html
+++ b/www/index.html
@@ -12,7 +12,7 @@
<body>
<div id="menu">
<div>
- <a href="http://llvm.org/">LLVM Home</a>
+ <a href="https://llvm.org/">LLVM Home</a>
</div>
<div class="submenu">
@@ -22,11 +22,11 @@
<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="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
+ <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
<a href="https://bugs.llvm.org/">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>
+ <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
+ <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
</div>
</div>
@@ -39,7 +39,7 @@
C++11.</p>
<p>All of the code in libc++ is <a
- href="http://llvm.org/docs/DeveloperPolicy.html#license">dual licensed</a>
+ href="https://llvm.org/docs/DeveloperPolicy.html#license">dual licensed</a>
under the MIT license and the UIUC License (a BSD-like license).</p>
<!--=====================================================================-->
@@ -49,7 +49,7 @@
<p> Looking for documentation on how to use, build and test libc++? If so
checkout the new libc++ documentation.</p>
- <p><a href="http://libcxx.llvm.org/docs/">
+ <p><a href="https://libcxx.llvm.org/docs/">
Click here for the new libc++ documentation.</a></p>
<!--=====================================================================-->
@@ -138,6 +138,8 @@
C++14 can be found <a href="cxx1y_status.html">here</a>.</p>
<p>A list of features and changes for the next C++ standard, known here as
"C++1z" (probably to be C++17) can be found <a href="cxx1z_status.html">here</a>.</p>
+ <p>A list of features and changes for the C++ standard beyond C++17, known here as
+ "C++2a" (probably to be C++20) can be found <a href="cxx2a_status.html">here</a>.</p>
<p>Implementation of the post-c++14 Technical Specifications is in progress. A list of features and
the current status of these features can be found <a href="ts1z_status.html">here</a>.</p>
@@ -159,17 +161,17 @@
<!--=====================================================================-->
<p>First please review our
- <a href="http://llvm.org/docs/DeveloperPolicy.html">Developer's Policy</a>.
+ <a href="https://llvm.org/docs/DeveloperPolicy.html">Developer's Policy</a>.
The documentation for building and using libc++ can be found below.
<ul>
- <li><a href="http://libcxx.llvm.org/docs/UsingLibcxx.html">
+ <li><a href="https://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">
+ <li><a href="https://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">
+ <li><a href="https://libcxx.llvm.org/docs/TestingLibcxx.html">
<b>Testing libc++</b></a>
Documentation for developers wishing to test the library</li>
</ul>
@@ -193,7 +195,7 @@
</p>
<p>Send discussions to the
- <a href="http://lists.llvm.org/mailman/listinfo/cfe-dev">clang mailing list</a>.</p>
+ <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">clang mailing list</a>.</p>
<!--=====================================================================-->
<h2>Bug reports and patches</h2>
@@ -201,14 +203,14 @@
<p>
If you think you've found a bug in libc++, please report it using
- the <a href="http://llvm.org/bugs">LLVM Bugzilla</a>. If you're not sure, you
- can post a message to the <a href="http://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
+ the <a href="https://bugs.llvm.org/">LLVM Bugzilla</a>. If you're not sure, you
+ can post a message to the <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
mailing list or on IRC. Please include "libc++" in your subject.
</p>
<p>
If you want to contribute a patch to libc++, the best place for that is
- <a href="http://llvm.org/docs/Phabricator.html">Phabricator</a>. Please
+ <a href="https://llvm.org/docs/Phabricator.html">Phabricator</a>. Please
include [libc++] in the subject and add cfe-commits as a subscriber.
</p>
@@ -219,7 +221,7 @@
<ul>
<li><a href="atomic_design.html"><tt><atomic></tt></a></li>
<li><a href="type_traits_design.html"><tt><type_traits></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="https://cplusplusmusings.wordpress.com/2012/07/05/clang-and-standard-libraries-on-mac-os-x/">Excellent notes by Marshall Clow</a></li>
</ul>
</div>
diff --git a/www/ts1z_status.html b/www/ts1z_status.html
index 48ce454..22ad0d4 100644
--- a/www/ts1z_status.html
+++ b/www/ts1z_status.html
@@ -12,7 +12,7 @@
<body>
<div id="menu">
<div>
- <a href="http://llvm.org/">LLVM Home</a>
+ <a href="https://llvm.org/">LLVM Home</a>
</div>
<div class="submenu">
@@ -22,11 +22,11 @@
<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="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
+ <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
<a href="https://bugs.llvm.org/">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>
+ <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
+ <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
</div>
</div>
@@ -37,20 +37,20 @@
<p>In November 2014, the C++ standard committee approved the draft for the next version of the C++ standard, known as "C++1z" (probably to be C++17)</p>
<p>In addition, there are several "Technical Specifications", that consist of new features that are proposed, but not yet accepted for C++1z.</p>
- <p>This page shows the status of libc++; the status of clang's support of the language features is <a href="http://clang.llvm.org/cxx_status.html">here</a>.</p>
+ <p>This page shows the status of libc++; the status of clang's support of the language features is <a href="https://clang.llvm.org/cxx_status.html">here</a>.</p>
<h3>Technical Specifications</h3>
<table id="TS" border="1">
<tr><th>Paper Number</th><th>Paper Title</th><th>TS</th></tr>
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4023.html">4023</a></td><td>C++ Extensions for Library Fundamentals</td><td>Library Fundamentals 1</td></tr>
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3940.html">3940</a></td><td>Technical Specification - File System</td><td>File System</td></tr>
+ <tr><td><a href="https://wg21.link/n4023">4023</a></td><td>C++ Extensions for Library Fundamentals</td><td>Library Fundamentals 1</td></tr>
+ <tr><td><a href="https://wg21.link/n3940">3940</a></td><td>Technical Specification - File System</td><td>File System</td></tr>
<tr><td></td><td></td><td></td></tr>
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4273">4273</a></td><td>Uniform Container Erasure.</td><td>Library Fundamentals 2</td></tr>
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4061">4061</a></td><td>Greatest Common Divisor and Least Common Multiple.</td><td>Library Fundamentals 2</td></tr>
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4257">4257</a></td><td>Delimited iterators.</td><td>Library Fundamentals 2</td></tr>
- <tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4282">4282</a></td><td>The World's Dumbest Smart Pointer.</td><td>Library Fundamentals 2</td></tr>
+ <tr><td><a href="https://wg21.link/n4273">4273</a></td><td>Uniform Container Erasure.</td><td>Library Fundamentals 2</td></tr>
+ <tr><td><a href="https://wg21.link/n4061">4061</a></td><td>Greatest Common Divisor and Least Common Multiple.</td><td>Library Fundamentals 2</td></tr>
+ <tr><td><a href="https://wg21.link/n4257">4257</a></td><td>Delimited iterators.</td><td>Library Fundamentals 2</td></tr>
+ <tr><td><a href="https://wg21.link/n4282">4282</a></td><td>The World's Dumbest Smart Pointer.</td><td>Library Fundamentals 2</td></tr>
<tr><td></td><td></td><td></td></tr>
</table>
@@ -95,7 +95,7 @@
<!-- <tr><td></td><td></td></tr> -->
</table>
-
+
<h3>Features in Filesystem</h3>
<table id="Features" border="1">
<tr><th>Feature Name</th><th>Status</th><th>First released version</th></tr>
diff --git a/www/type_traits_design.html b/www/type_traits_design.html
index 2c7f73b..1cab293 100644
--- a/www/type_traits_design.html
+++ b/www/type_traits_design.html
@@ -12,7 +12,7 @@
<body>
<div id="menu">
<div>
- <a href="http://llvm.org/">LLVM Home</a>
+ <a href="https://llvm.org/">LLVM Home</a>
</div>
<div class="submenu">
@@ -22,11 +22,11 @@
<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="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
+ <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
<a href="https://bugs.llvm.org/">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>
+ <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
+ <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
</div>
</div>
@@ -39,7 +39,7 @@
This is a survey of the type traits intrinsics clang has, and those needed.
The names and definitions of several of the needed type traits has recently
changed. Please see:
-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3142.html">N3142</a>.
+<a href="https://wg21.link/n3142">N3142</a>.
</p>
<blockquote>
diff --git a/www/upcoming_meeting.html b/www/upcoming_meeting.html
index 90a1928..b57b786 100644
--- a/www/upcoming_meeting.html
+++ b/www/upcoming_meeting.html
@@ -12,7 +12,7 @@
<body>
<div id="menu">
<div>
- <a href="http://llvm.org/">LLVM Home</a>
+ <a href="https://llvm.org/">LLVM Home</a>
</div>
<div class="submenu">
@@ -22,11 +22,11 @@
<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="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
+ <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
<a href="https://bugs.llvm.org/">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>
+ <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
+ <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
</div>
</div>
@@ -35,8 +35,8 @@
<h1>libc++ Issaquah 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 Issaquah.</p>
+ <p>This is a temporary page; please check the c++1z status <a href="cxx1z_status.html">here</a></p>
+ <p>This page shows the status of the papers and issues that are expected to be adopted in Toronto.</p>
<p>The groups that have contributed papers:
<ul>
@@ -45,12 +45,12 @@
<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><a href="https://wg21.link/n3346">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>
@@ -59,71 +59,45 @@
<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/LWG2260">2260</a></td><td>Missing requirement for Allocator::pointer</td><td>Kona</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2768">2768</a></td><td>any_cast and move semantics</td><td>Kona</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2769">2769</a></td><td>Redundant const in the return type of any_cast(const any&)</td><td>Kona</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2781">2781</a></td><td>Contradictory requirements for std::function and std::reference_wrapper</td><td>Kona</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2782">2782</a></td><td>scoped_allocator_adaptor constructors must be constrained</td><td>Kona</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2784">2784</a></td><td>Resolution to LWG 2484 is missing "otherwise, no effects" and is hard to parse</td><td>Kona</td><td><i>Patch Ready</i></td></tr>
- <tr><td><a href="http://wg21.link/LWG2785">2785</a></td><td>quoted should work with basic_string_view</td><td>Kona</td><td><i>We do this already</i></td></tr>
- <tr><td><a href="http://wg21.link/LWG2786">2786</a></td><td>Annex C should mention shared_ptr changes for array support</td><td>Kona</td><td><i>Nothing to do</i></td></tr>
- <tr><td><a href="http://wg21.link/LWG2787">2787</a></td><td>§[file_status.cons] doesn't match class definition</td><td>Kona</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2789">2789</a></td><td>Equivalence of contained objects</td><td>Kona</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2794">2794</a></td><td>Missing requirements for allocator pointers</td><td>Kona</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2795">2795</a></td><td>§[global.functions] provides incorrect example of ADL use</td><td>Kona</td><td><i>Nothing to do</i></td></tr>
- <tr><td><a href="http://wg21.link/LWG2804">2804</a></td><td>Unconditional constexpr default constructor for istream_iterator</td><td>Kona</td><td><i>We do this already</i></td></tr>
- <tr><td><a href="http://wg21.link/LWG2812">2812</a></td><td>Range access is available with <string_view></td><td>Kona</td><td><i>We do this already</i></td></tr>
- <tr><td><a href="http://wg21.link/LWG2824">2824</a></td><td>list::sort should say that the order of elements is unspecified if an exception is thrown</td><td>Kona</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2826">2826</a></td><td>string_view iterators use old wording</td><td>Kona</td><td><i>Nothing to do</i></td></tr>
- <tr><td><a href="http://wg21.link/LWG2834">2834</a></td><td>Resolution LWG 2223 is missing wording about end iterators</td><td>Kona</td><td><i>Nothing to do</i></td></tr>
- <tr><td><a href="http://wg21.link/LWG2835">2835</a></td><td>LWG 2536 seems to misspecify <tgmath.h></td><td>Kona</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2837">2837</a></td><td>gcd and lcm should support a wider range of input values</td><td>Kona</td><td><i>We do this already</i></td></tr>
- <tr><td><a href="http://wg21.link/LWG2838">2838</a></td><td>is_literal_type specification needs a little cleanup</td><td>Kona</td><td><i>Nothing to do</i></td></tr>
- <tr><td><a href="http://wg21.link/LWG2842">2842</a></td><td>in_place_t check for optional::optional(U&&) should decay U</td><td>Kona</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2850">2850</a></td><td>std::function move constructor does unnecessary work</td><td>Kona</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2853">2853</a></td><td>Possible inconsistency in specification of erase in [vector.modifiers]</td><td>Kona</td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2855">2855</a></td><td>std::throw_with_nested("string_literal")</td><td>Kona</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2444">2444</a></td><td>Inconsistent complexity for std::sort_heap</td><td>Toronto</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2593">2593</a></td><td>Moved-from state of Allocators</td><td>Toronto</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2597">2597</a></td><td>std::log misspecified for complex numbers</td><td>Toronto</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2783">2783</a></td><td>stack::emplace() and queue::emplace() should return decltype(auto)</td><td>Toronto</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2932">2932</a></td><td>Constraints on parallel algorithm implementations are underspecified</td><td>Toronto</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2937">2937</a></td><td>Is equivalent("existing_thing", "not_existing_thing") an error?</td><td>Toronto</td><td>Complete</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2940">2940</a></td><td>result_of specification also needs a little cleanup</td><td>Toronto</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2942">2942</a></td><td>LWG 2873's resolution missed weak_ptr::owner_before</td><td>Toronto</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2954">2954</a></td><td>Specialization of the convenience variable templates should be prohibited</td><td>Toronto</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2961">2961</a></td><td>Bad postcondition for set_default_resource</td><td>Toronto</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2966">2966</a></td><td>Incomplete resolution of US 74</td><td>Toronto</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2974">2974</a></td><td>Diagnose out of bounds tuple_element/variant_alternative</td><td>Toronto</td><td></td></tr>
<tr><td></td><td><center><b>Priority 1 Bugs</b></center></td><td></td><td></td></tr>
- <tr><td><a href="http://wg21.link/LWG2665">2665</a></td><td>remove_filename() post condition is incorrect</td><td>Kona</td><td>We do this already</td></tr>
- <tr><td><a href="http://wg21.link/LWG2806">2806</a></td><td>Base class of bad_optional_access</td><td>Kona</td><td><i>We do this already</i></td></tr>
- <tr><td><a href="http://wg21.link/LWG2857">2857</a></td><td>{variant,optional,any}::emplace should return the constructed value</td><td>Kona</td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2665">2665</a></td><td>remove_filename() post condition is incorrect</td><td>Toronto</td><td>We do this already</td></tr>
+
+ <tr><td></td><td><center><b>Immediate Issues in Toronto</b></center></td><td></td><td></td></tr>
+ <tr><td><a href="https://wg21.link/LWG2901">2901</a></td><td>Variants cannot properly support allocators</td><td>Toronto</td><td>We do this already</td></tr>
+ <tr><td><a href="https://wg21.link/LWG2956">2956</a></td><td><tt>filesystem::canonical()</tt> still defined in terms of <tt>absolute(p, base)</tt></td><td>Toronto</td><td></td></tr>
</table>
<h3>Comments about the issues</h3>
<ul>
-<li>2260 - Check our current allocators to make sure we do this</li>
-<li>2768 - Resolution is "apply 2769"</li>
-<li>2769 - This should be easy; trick will be devising tests.</li>
-<li>2781 - </li>
-<li>2782 - Looks straightforward.</li>
-<li>2784 - Patch Ready</li>
-<li>2785 - We do this already.</li>
-<li>2786 - Nothing to do; just moving words around</li>
-<li>2787 - Eric? </li>
-<li>2789 - I don't think there are any code changes required here</li>
-<li>2794 - I don't think there are any code changes required here - maybe a static_assert.</li>
-<li>2795 - Nothing to do; just moving words around</li>
-<li>2804 - We do this already.</li>
-<li>2812 - We do this already.</li>
-<li>2824 - Nothing do to here, but we should add some throwing sort tests.</li>
-<li>2826 - Nothing to do; just moving words around</li>
-<li>2834 - Nothing to do; just moving words around</li>
-<li>2835 - I'm pretty sure we already do this.</li>
-<li>2837 - Added some tests to ensure we do this already.</li>
-<li>2838 - Nothing to do; just moving words around</li>
-<li>2842 - This should be easy; trick will be devising tests.</li>
-<li>2850 - I think we already do this.</li>
-<li>2853 - I think that this will be mostly adding tests.</li>
-<li>2855 - This should be easy; trick will be devising tests.</li></li>
-<li></li>
-<li>2665 - We do this already.</li>
-<li>2806 - We do this already.</li>
-<li>2857 - This is the subject of several NB comments.</li>
+<li>2444 - </li>
+<li>2593 - </li>
+<li>2597 - I think we do this already; probably needs tests</li>
+<li>2783 - should be easy to change; needs tests</li>
+<li>2932 - We're not doing the parallel algorithms yet.</li>
+<li>2937 - Implemented with tests. The PR LGTM (Eric)</li>
+<li>2940 - We haven't implemented result_of yet, but I don't think that this will require any changes.</li>
+<li>2942 - all of our owner_before overloads are already noexcept; just need to update the tests.</li>
+<li>2954 - I don't think there's anything to do here.</li>
+<li>2961 - We haven't implemented the PMR stuff yet.</li>
+<li>2966 - Wording cleanup; no code or test changes needed.</li>
+<li>2974 - I did this in r305196. Tests added in 306580</li>
</ul>
-<p>Last Updated: 7-Feb-2017</p>
+<p>Last Updated: 28-Jun-2017</p>
</div>
</body>
</html>
