#include <algorithm>
#include <vector>
+#include "test_macros.h"
+
struct gen
{
std::ptrdiff_t operator()(std::ptrdiff_t n)
#include <algorithm>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <atomic>
#include <type_traits>
+#include "test_macros.h"
+
enum cpp17_memory_order {
cpp17_memory_order_relaxed, cpp17_memory_order_consume, cpp17_memory_order_acquire,
#include <atomic>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <cstdlib>
#include <map>
+#include "test_macros.h"
+
void exit_success(int) {
std::_Exit(EXIT_SUCCESS);
#include <cstdlib>
#include <map>
+#include "test_macros.h"
+
void exit_success(int) {
std::_Exit(EXIT_SUCCESS);
#include <map>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <map>
#include <functional>
+#include "test_macros.h"
+
template <template <typename ...> class Container>
void test_set() {
#include <set>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <__tree>
#include <cassert>
+#include "test_macros.h"
+
struct Node
{
Node* __left_;
#include <__tree>
#include <cassert>
+#include "test_macros.h"
+
struct Node
{
Node* __left_;
#include <__tree>
#include <cassert>
+#include "test_macros.h"
+
struct Node
{
Node* __left_;
#include <__tree>
#include <cassert>
+#include "test_macros.h"
+
struct Node
{
Node* __left_;
#include <map>
+#include "test_macros.h"
+
int main(int, char**) {
std::map<int, int> m;
((void)m);
#include <queue>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <stack>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
struct unique_ptr;
#include <ext/hash_map>
+#include "test_macros.h"
+
namespace __gnu_cxx {
template class hash_map<int, int>;
struct unique_ptr;
#include <ext/hash_set>
+#include "test_macros.h"
+
namespace __gnu_cxx {
template class hash_set<int>;
}
#define _LIBCPP_DEBUG 1
#include <array>
+#include "test_macros.h"
#include "debug_mode_helper.h"
int main(int, char**)
#define _LIBCPP_DEBUG 1
#include <array>
+#include "test_macros.h"
#include "debug_mode_helper.h"
int main(int, char**)
#define _LIBCPP_DEBUG 1
#include <array>
+#include "test_macros.h"
#include "debug_mode_helper.h"
int main(int, char**)
#include <array>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <deque>
#include <cassert>
+#include "test_macros.h"
+
struct A {
std::deque<A> d;
std::deque<A>::iterator it;
#include <cstdlib>
#include <deque>
+#include "test_macros.h"
+
int main(int, char**) {
std::deque<int> q;
#include <deque>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <forward_list>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::list<int> l1;
#include <list>
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
class A
{
int i_;
#include <cassert>
#include <cstdlib>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = {1, 2, 3};
#include <cassert>
#include <cstdlib>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = {1, 2, 3};
#include <cassert>
#include <cstdlib>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = {1, 2, 3};
#include <cassert>
#include <cstdlib>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = {1, 2, 3};
#include <cassert>
#include <cstdlib>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = {1, 2, 3};
#include <cassert>
#include <cstdlib>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = {1, 2, 3};
#include <list>
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
int main(int, char**)
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::list<int> v1(3);
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::list<int> c1(100);
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a[] = {1, 2, 3};
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <list>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <vector>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
std::vector<const int> v = {1, 2, 3};
#include <cstdlib>
#include <vector>
+#include "test_macros.h"
+
int main(int, char**) {
std::vector<int> v;
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
void test_ctor_under_alloc() {
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
void test_ctor_under_alloc() {
#include <vector>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <unordered_map>
#include <cassert>
+#include "test_macros.h"
+
bool
is_power_of_two(unsigned long n)
#include <__hash_table>
#include <cassert>
+#include "test_macros.h"
+
bool
is_prime(size_t n)
{
#include <unordered_map>
#include <functional>
+#include "test_macros.h"
+
template <template <typename ...> class Container>
void test_set() {
#include <cstdlib>
#include <unordered_map>
+#include "test_macros.h"
+
int main(int, char**) {
std::signal(SIGABRT, [](int) { std::_Exit(EXIT_SUCCESS); });
#include <cstdlib>
#include <unordered_map>
+#include "test_macros.h"
+
int main(int, char**) {
std::signal(SIGABRT, [](int) { std::_Exit(EXIT_SUCCESS); });
#include <unordered_map>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <unordered_set>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <utility>
#include <cassert>
#include "container_debug_tests.hpp"
+#include "test_macros.h"
#include "debug_mode_helper.h"
using namespace IteratorDebugChecks;
#include <vector>
#include "container_debug_tests.hpp"
+#include "test_macros.h"
+
template <typename Container>
Container makeContainer(int size) {
#include <vector>
#include <deque>
#include "container_debug_tests.hpp"
+#include "test_macros.h"
#include "debug_mode_helper.h"
using namespace IteratorDebugChecks;
#include <utility>
#include <cassert>
#include "container_debug_tests.hpp"
+#include "test_macros.h"
#include "debug_mode_helper.h"
using namespace IteratorDebugChecks;
#include <cstdlib>
#include <__debug>
+#include "test_macros.h"
+
void signal_handler(int signal)
{
if (signal == SIGABRT)
#define _LIBCPP_DEBUG 1
#include <__debug>
+#include "test_macros.h"
#include "debug_mode_helper.h"
#include <__debug>
#include <cassert>
+#include "test_macros.h"
+
void my_debug_function(std::__libcpp_debug_info const& info) {
assert(info.__msg_ == std::string("foo"));
std::exit(0);
#include <memory>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
std::auto_ptr<int> p;
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
int identity(int v) { return v; }
int sum(int a, int b) { return a + b; }
#include <strstream>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#define _LIBCPP_ENABLE_CXX17_REMOVED_FEATURES
#include <__config>
+#include "test_macros.h"
+
#ifndef _LIBCPP_ENABLE_CXX17_REMOVED_UNEXPECTED_FUNCTIONS
#error _LIBCPP_ENABLE_CXX17_REMOVED_UNEXPECTED_FUNCTIONS must be defined
#endif
#include <cassert>
#include <cstdlib>
+#include "test_macros.h"
+
void f1() {}
void f2() {}
#include <cassert>
#include <cstdlib>
+#include "test_macros.h"
+
void f1() {}
void f2() {}
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
void fexit()
{
std::exit(0);
#include <cassert>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <cerrno>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <__config>
+#include "test_macros.h"
+
_LIBCPP_NODISCARD_EXT int foo() { return 42; }
int main(int, char**) {
#define _LIBCPP_DISABLE_NODISCARD_AFTER_CXX17
#include <__config>
+#include "test_macros.h"
+
_LIBCPP_NODISCARD_AFTER_CXX17 int foo() { return 6; }
int main(int, char**)
#include <stdexcept>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <system_error>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <experimental/algorithm>
+#include "test_macros.h"
+
#ifndef _LIBCPP_ALGORITHM
# error "<experimental/algorithm> must include <algorithm>"
#endif
#include <experimental/algorithm>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
# error _LIBCPP_VERSION not defined
#endif
#endif
#include <experimental/system_error>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <experimental/filesystem>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <cstdlib>
#include "test_memory_resource.hpp"
+#include "test_macros.h"
+
namespace ex = std::experimental::pmr;
template <class T>
#include "test_memory_resource.hpp"
+#include "test_macros.h"
+
namespace ex = std::experimental::pmr;
int main(int, char**)
#include "test_memory_resource.hpp"
+#include "test_macros.h"
+
namespace ex = std::experimental::pmr;
int main(int, char**)
#include <experimental/deque>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error header must provide _LIBCPP_VERSION
#endif
#include <experimental/forward_list>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error header must provide _LIBCPP_VERSION
#endif
#include <experimental/list>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error header must provide _LIBCPP_VERSION
#endif
#include <experimental/map>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error header must provide _LIBCPP_VERSION
#endif
#include <experimental/regex>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error header must provide _LIBCPP_VERSION
#endif
#include <experimental/set>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error header must provide _LIBCPP_VERSION
#endif
#include <experimental/string>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error header must provide _LIBCPP_VERSION
#endif
#include <experimental/unordered_map>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error header must provide _LIBCPP_VERSION
#endif
#include <experimental/unordered_set>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error header must provide _LIBCPP_VERSION
#endif
#include <experimental/vector>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error header must provide _LIBCPP_VERSION
#endif
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
namespace ex = std::experimental::pmr;
struct POSType {
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
namespace ex = std::experimental::pmr;
struct POSType {
#include <experimental/memory_resource>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#endif
#include <experimental/numeric>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#endif
#include <experimental/string_view>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#endif
#include <experimental/any>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <experimental/type_traits>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#endif
#include <experimental/optional>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#endif
#include <experimental/ratio>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#endif
#include <experimental/chrono>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#endif
#include <experimental/tuple>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <experimental/utility>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <ext/hash_map>
#include <string>
+#include "test_macros.h"
+
int main(int, char**)
{
char str[] = "test";
#include <cstdio>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <cinttypes>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <fstream>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
int main(int, char**)
#include <fstream>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
int main(int, char**)
#include <fstream>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
int main(int, char**)
#include <fstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
#include <fstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
#include <fstream>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
int main(int, char**)
#include <fstream>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
int main(int, char**)
#include <fstream>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <filesystem>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <istream>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <ostream>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <iomanip>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <iosfwd>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <iostream>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <ios>
#include <streambuf>
+#include "test_macros.h"
+
void exit_success(int) {
std::_Exit(EXIT_SUCCESS);
#include <ios>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <streambuf>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <sstream>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#define _LIBCPP_DEBUG 0
#include <iterator>
+#include "test_macros.h"
#include "debug_mode_helper.h"
#include "test_iterators.h"
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#define _LIBCPP_DEBUG 0
#include <iterator>
+#include "test_macros.h"
#include "debug_mode_helper.h"
#include "test_iterators.h"
#define _LIBCPP_DEBUG 0
#include <iterator>
+#include "test_macros.h"
#include "debug_mode_helper.h"
#include "test_iterators.h"
#include <iterator>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <compare>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <cstdint>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <new>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <exception>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <initializer_list>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <cfloat>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <climits>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <limits>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <version>
+#include "test_macros.h"
+
#if !defined(_LIBCPP_VERSION)
#error "_LIBCPP_VERSION must be defined after including <version>"
#endif
#include <typeinfo>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <csetjmp>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <csignal>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <cstdarg>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <cstdbool>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <cstdlib>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <ctime>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <cstddef>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <clocale>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
const std::ctype<char>& ct = std::use_facet<std::ctype<char> >(std::locale::classic());
#include <codecvt>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <cstdlib>
#include <locale>
+#include "test_macros.h"
+
void exit_success(int) {
std::_Exit(EXIT_SUCCESS);
#include <cstdlib>
#include <locale>
+#include "test_macros.h"
+
void exit_success(int) {
std::_Exit(EXIT_SUCCESS);
#include <codecvt>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::codecvt_utf8<wchar_t> Codecvt;
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
struct my_facet
: public std::locale::facet
{
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
std::locale::id id0;
std::locale::id id2;
std::locale::id id1;
#include <cstdlib>
#include <locale>
+#include "test_macros.h"
+
struct my_facet : public std::locale::facet {
static std::locale::id id;
#include <locale>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <new>
+#include "test_macros.h"
+
#ifdef _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
# error "libc++ should have aligned allocation in C++17 and up when targeting a platform that supports it"
#include <cmath>
+#include "test_macros.h"
+
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, "");
#include <ctgmath>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <tgmath.h>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <cmath>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <cfenv>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <complex>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
void
test()
#include <ccomplex>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <complex>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <valarray>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <numeric>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <random>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::string l = "Long string so that allocation definitely, for sure, absolutely happens. Probably.";
#include <stdexcept>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
#if _LIBCPP_DEBUG >= 1
#include <cctype>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <cstring>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <cuchar>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <cwchar>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <cwctype>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <string>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
#include "debug_mode_helper.h"
int main(int, char**)
#include <exception>
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
#include "debug_mode_helper.h"
#include <future>
#include <type_traits>
+#include "test_macros.h"
+
struct A {};
int main(int, char**)
#include <future>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <cassert>
#include <pthread.h>
+#include "test_macros.h"
+
std::condition_variable cv;
std::mutex mut;
bool exited = false;
#include <condition_variable>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_same<std::condition_variable::native_handle_type,
#include <condition_variable>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <mutex>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::mutex m;
#include <mutex>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::recursive_mutex m;
#include <mutex>
+#include "test_macros.h"
+
int main(int, char**) {
std::mutex m;
m.lock();
#include <mutex>
+#include "test_macros.h"
+
std::mutex m;
int foo __attribute__((guarded_by(m)));
#include <mutex>
+#include "test_macros.h"
+
std::mutex m;
int foo __attribute__((guarded_by(m)));
#include <mutex>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
class G
{
int alive_;
#include <thread>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_same<std::thread::native_handle_type, pthread_t>::value), "");
#include <signal.h>
#include <sys/time.h>
+#include "test_macros.h"
+
void sig_action(int) {}
int main(int, char**)
#include <thread>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include "user_defined_integral.hpp"
+#include "test_macros.h"
+
template <class T>
struct EnumType
{
#include <type_traits>
+#include "test_macros.h"
+
template <class Type>
struct Identity {
typedef Type type;
#include <any>
+#include "test_macros.h"
+
int main(int, char**)
{
using std::any;
// Check that the size and alignment of any are what we expect.
#include <any>
+#include "test_macros.h"
#include "any_helpers.h"
constexpr std::size_t BufferSize = (sizeof(void*) * 3);
#include <any>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <functional>
#include <type_traits>
+#include "test_macros.h"
+
class functor1
: public std::unary_function<int, char>
{
#include <functional>
#include <type_traits>
+#include "test_macros.h"
+
class functor1
: public std::unary_function<int, char>
{
#include <functional>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <thread>
#include <cassert>
+#include "test_macros.h"
+
typedef std::shared_ptr<int> Ptr;
typedef std::weak_ptr<int> WeakPtr;
#include <memory>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <type_traits>
+#include "test_macros.h"
+
struct A
{
#include <type_traits>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <string>
#include <type_traits>
+#include "test_macros.h"
+
using std::optional;
struct X {};
#include <type_traits>
#include <utility>
+#include "test_macros.h"
+
using std::optional;
struct X {};
#include <string>
#include <type_traits>
+#include "test_macros.h"
+
using std::optional;
struct X {};
#include <type_traits>
#include <utility>
+#include "test_macros.h"
+
using std::optional;
struct X {};
#include "archetypes.hpp"
+#include "test_macros.h"
+
template <class T>
struct SpecialMemberTest {
using O = std::optional<T>;
#include <optional>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <ratio>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <bitset>
+#include "test_macros.h"
+
#ifndef _LIBCPP_CSTDDEF
#error <cstddef> has not been included
#endif
#include <bitset>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <chrono>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <tuple>
+#include "test_macros.h"
+
struct A {};
struct B {};
#include <tuple>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <typeindex>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <utility>
+#include "test_macros.h"
+
struct S {};
int main(int, char**) {
#include <utility>
+#include "test_macros.h"
+
struct S {};
int main(int, char**) {
#include <utility>
+#include "test_macros.h"
+
struct ExplicitT {
constexpr explicit ExplicitT(int x) : value(x) {}
#include "archetypes.hpp"
+#include "test_macros.h"
+
// Clang warns about missing braces when initializing std::array.
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wmissing-braces"
#include <utility>
+#include "test_macros.h"
+
struct ExplicitT {
constexpr explicit ExplicitT(int x) : value(x) {}
#include <utility>
+#include "test_macros.h"
+
struct ExplicitT {
constexpr explicit ExplicitT(int x) : value(x) {}
#include <utility>
#include <type_traits>
+#include "test_macros.h"
+
struct ThrowingDefault {
ThrowingDefault() { }
#include "archetypes.hpp"
+#include "test_macros.h"
+
int main(int, char**) {
using NonThrowingConvert = NonThrowingTypes::ConvertingType;
#include <type_traits>
#include <utility>
+#include "test_macros.h"
+
struct ExplicitT {
constexpr explicit ExplicitT(int x) : value(x) {}
#include <utility>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <utility>
#include <variant>
+#include "test_macros.h"
+
template <class Sequence>
struct make_variant_imp;
#include <variant>
+#include "test_macros.h"
+
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
struct is_odd
#include <random>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
// Stable if and only if PopulationIterator meets the requirements of a
#include <algorithm>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <class Iter>
#include <algorithm>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int i = 1;
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
struct Tag {
Tag() : val(0), tag("Default") {}
Tag(int a, const char *b) : val(a), tag(b) {}
#include <algorithm>
#include <cassert>
+#include "test_macros.h"
+
struct Tag {
Tag() : val(0), tag("Default") {}
Tag(int a, const char *b) : val(a), tag(b) {}
#include <random>
#include <cassert>
+#include "test_macros.h"
+
std::mt19937 randomness;
void test(int N)
#include <random>
#include <cassert>
+#include "test_macros.h"
+
std::mt19937 randomness;
void test(int N)
#include <random>
#include <cassert>
+#include "test_macros.h"
+
std::mt19937 randomness;
void test(int N)
#include <random>
#include <cassert>
+#include "test_macros.h"
+
std::mt19937 randomness;
void test(int N)
#include <random>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#if TEST_STD_VER >= 11
#include <random>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
std::mt19937 randomness;
#include <random>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
std::mt19937 randomness;
#include <random>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
std::mt19937 randomness;
#include <random>
#include <cassert>
+#include "test_macros.h"
+
std::mt19937 randomness;
void
#include <algorithm>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include <cstdio>
#include <functional>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include <cstdio>
#include <algorithm>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include <cstdio>
#include <functional>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include <cstdio>
#include <algorithm>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <class Iter1, class Iter2, class OutIter>
#include <functional>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <class Iter1, class Iter2, class OutIter>
#include <algorithm>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <class Iter1, class Iter2, class OutIter>
#include <functional>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <class Iter1, class Iter2, class OutIter>
#include <algorithm>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <class Iter1, class Iter2, class OutIter>
#include <functional>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <class Iter1, class Iter2, class OutIter>
#include <iterator>
#include <vector>
+#include "test_macros.h"
#include "MoveOnly.h"
#include <algorithm>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#if TEST_STD_VER > 17
#include <functional>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#if TEST_STD_VER > 17
#include <algorithm>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#if TEST_STD_VER > 17
#include <functional>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#if TEST_STD_VER > 17
#include <random>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
std::mt19937 randomness;
#include <random>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
std::mt19937 randomness;
#include <random>
#include <cassert>
+#include "test_macros.h"
+
std::mt19937 randomness;
void
#include <random>
#include <cassert>
+#include "test_macros.h"
+
std::mt19937 randomness;
template <class RI>
#include <random>
#include <cassert>
+#include "test_macros.h"
+
std::mt19937 randomness;
template <class RI>
#include <atomic>
+#include "test_macros.h"
+
int main(int, char**)
{
std::atomic_signal_fence(std::memory_order_seq_cst);
#include <atomic>
+#include "test_macros.h"
+
int main(int, char**)
{
std::atomic_thread_fence(std::memory_order_seq_cst);
#include <atomic>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <atomic>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <atomic>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <atomic>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <atomic>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <atomic>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::atomic_flag f = ATOMIC_FLAG_INIT;
#include <atomic>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <atomic>
+#include "test_macros.h"
+
int main(int, char**) {
std::atomic<int> i;
volatile std::atomic<int> v;
#include <atomic>
#include <cassert>
+#include "test_macros.h"
+
#if !defined(__cpp_lib_atomic_is_always_lock_free)
# error Feature test macro missing.
#endif
#include <atomic>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
assert(ATOMIC_BOOL_LOCK_FREE == 0 ||
#include <atomic>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
assert(std::kill_dependency(5) == 5);
#include <atomic>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
assert(static_cast<int>(std::memory_order_relaxed) == 0);
#include <atomic>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert(std::memory_order_relaxed == std::memory_order::relaxed);
#include <type_traits>
#include <cstdint>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_same<std::atomic< std::int_least8_t>, std::atomic_int_least8_t>::value), "");
#include <atomic>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_same<std::atomic<char>, std::atomic_char>::value), "");
#include <thread> // for thread_id
#include <chrono> // for nanoseconds
+#include "test_macros.h"
+
struct TriviallyCopyable {
TriviallyCopyable ( int i ) : i_(i) {}
int i_;
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
#include "atomic_helpers.h"
template <class T>
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
#include "atomic_helpers.h"
template <class T>
#include <cassert>
#include <cmpxchg_loop.h>
+#include "test_macros.h"
#include "atomic_helpers.h"
template <class T>
#include <cmpxchg_loop.h>
+#include "test_macros.h"
#include "atomic_helpers.h"
template <class T>
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
#include "atomic_helpers.h"
template <class T>
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
#include "atomic_helpers.h"
template <class T>
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
#include "atomic_helpers.h"
template <class T>
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
#include "atomic_helpers.h"
template <class T>
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
#include "atomic_helpers.h"
template <class T>
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
#include "atomic_helpers.h"
template <class T>
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
#include "atomic_helpers.h"
template <class T>
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
#include "atomic_helpers.h"
template <class T>
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
#include "atomic_helpers.h"
template <class T>
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
#include "atomic_helpers.h"
template <class T>
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
#include "atomic_helpers.h"
template <class T>
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
#include "atomic_helpers.h"
template <class T>
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
#include "atomic_helpers.h"
template <class T>
#include <atomic>
#include <cassert>
+#include "test_macros.h"
#include "atomic_helpers.h"
template <class T>
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
#include "atomic_helpers.h"
template <class T>
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
#include "atomic_helpers.h"
template <class T>
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
#include "atomic_helpers.h"
template <class T>
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
#include "atomic_helpers.h"
template <class T>
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::atomic<int> v = ATOMIC_VAR_INIT(5);
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
#include "atomic_helpers.h"
struct UserType {
#include <utility>
#include <cassert>
+#include "test_macros.h"
+
struct Key {
template <typename T> Key(const T&) {}
bool operator< (const Key&) const { return false; }
#include <map>
std::map<int,int>::iterator it;
#include <set>
+
+#include "test_macros.h"
using std::set;
using std::multiset;
#include <map>
+#include "test_macros.h"
+
struct A {
typedef std::map<A, A> Map;
int data;
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <tuple>
+#include "test_macros.h"
+
int main(int, char**)
{
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "../../../test_compare.h"
#include "min_allocator.h"
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "../../../test_compare.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "../../../test_compare.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <iostream>
+#include "test_macros.h"
#include "../../../test_compare.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <map>
+#include "test_macros.h"
+
struct X
{
std::map<int, X> m;
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "../../../test_compare.h"
#include "min_allocator.h"
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "../../../test_compare.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "../../../test_compare.h"
#include "min_allocator.h"
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "../../../test_compare.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "../../../test_compare.h"
#include "test_allocator.h"
#include <cassert>
#include <tuple>
+#include "test_macros.h"
#include "../../../Emplaceable.h"
#include "DefaultOnly.h"
#include "min_allocator.h"
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "../../../Emplaceable.h"
#include "DefaultOnly.h"
#include "min_allocator.h"
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
struct TemplateConstructor
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
// node_type extract(const_iterator);
#include <map>
+#include "test_macros.h"
#include "min_allocator.h"
#include "Counter.h"
// node_type extract(key_type const&);
#include <map>
+#include "test_macros.h"
#include "min_allocator.h"
#include "Counter.h"
#include <map>
+#include "test_macros.h"
#include "container_test_types.h"
#include "../../../map_allocator_requirement_test_templates.h"
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "min_allocator.h"
#include <map>
#include <type_traits>
+#include "test_macros.h"
#include "min_allocator.h"
template <class Container>
// iterator insert(const_iterator hint, node_type&&);
#include <map>
+#include "test_macros.h"
#include "min_allocator.h"
template <class Container>
#include <iostream>
+#include "test_macros.h"
+
class Moveable
{
Moveable(const Moveable&);
#include <cassert>
#include <tuple>
+#include "test_macros.h"
+
class Moveable
{
Moveable(const Moveable&);
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "is_transparent.h"
int main(int, char**)
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "is_transparent.h"
int main(int, char**)
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "is_transparent.h"
int main(int, char**)
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "is_transparent.h"
int main(int, char**)
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "is_transparent.h"
int main(int, char**)
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "../../../test_compare.h"
#include "min_allocator.h"
#include <map>
#include <type_traits>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <map>
+#include "test_macros.h"
+
struct A {
typedef std::multimap<A, A> Map;
int data;
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "../../../test_compare.h"
#include "min_allocator.h"
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "../../../test_compare.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "../../../test_compare.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "../../../test_compare.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <map>
+#include "test_macros.h"
+
struct X
{
std::multimap<int, X> m;
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "../../../test_compare.h"
#include "min_allocator.h"
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "../../../test_compare.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "../../../test_compare.h"
#include "min_allocator.h"
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "../../../test_compare.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "../../../test_compare.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "../../../test_compare.h"
#include "test_allocator.h"
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "../../../Emplaceable.h"
#include "DefaultOnly.h"
#include "min_allocator.h"
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "../../../Emplaceable.h"
#include "DefaultOnly.h"
#include "min_allocator.h"
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
struct TemplateConstructor
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
// node_type extract(const_iterator);
#include <map>
+#include "test_macros.h"
#include "min_allocator.h"
#include "Counter.h"
// node_type extract(key_type const&);
#include <map>
+#include "test_macros.h"
#include "min_allocator.h"
#include "Counter.h"
#include <map>
+#include "test_macros.h"
#include "container_test_types.h"
#include "../../../map_allocator_requirement_test_templates.h"
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "min_allocator.h"
#include <map>
#include <type_traits>
+#include "test_macros.h"
#include "min_allocator.h"
template <class Container>
// iterator insert(const_iterator hint, node_type&&);
#include <map>
+#include "test_macros.h"
#include "min_allocator.h"
template <class Container>
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "is_transparent.h"
int main(int, char**)
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "is_transparent.h"
int main(int, char**)
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "is_transparent.h"
int main(int, char**)
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "is_transparent.h"
int main(int, char**)
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "is_transparent.h"
int main(int, char**)
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "../../../test_compare.h"
#include "min_allocator.h"
#include <map>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::map<int, int> M1;
#include <map>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <map>
#include <type_traits>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "../../Emplaceable.h"
#include "DefaultOnly.h"
#include "min_allocator.h"
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "../../Emplaceable.h"
#include "DefaultOnly.h"
#include "min_allocator.h"
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
struct TemplateConstructor
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
// node_type extract(const_iterator);
#include <set>
+#include "test_macros.h"
#include "min_allocator.h"
#include "Counter.h"
// node_type extract(key_type const&);
#include <set>
+#include "test_macros.h"
#include "min_allocator.h"
#include "Counter.h"
#include <set>
+#include "test_macros.h"
+
struct A {
typedef std::multiset<A> Set;
int data;
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template<class Container>
#include <set>
+#include "test_macros.h"
#include "container_test_types.h"
#include "../../set_allocator_requirement_test_templates.h"
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "min_allocator.h"
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "min_allocator.h"
#include <set>
#include <type_traits>
+#include "test_macros.h"
#include "min_allocator.h"
template <class Container>
// iterator insert(const_iterator hint, node_type&&);
#include <set>
+#include "test_macros.h"
#include "min_allocator.h"
template <class Container>
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "min_allocator.h"
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
int main(int, char**)
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "../../../test_compare.h"
int main(int, char**)
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "../../../test_compare.h"
#include "test_allocator.h"
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "../../../test_compare.h"
#include "test_allocator.h"
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "../../../test_compare.h"
#include "test_allocator.h"
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "../../../test_compare.h"
int main(int, char**)
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "../../../test_compare.h"
#include "test_allocator.h"
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "min_allocator.h"
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "../../../test_compare.h"
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "../../../test_compare.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "../../../test_compare.h"
#include "test_allocator.h"
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "../../../test_compare.h"
#include <set>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::set<int> M1;
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <set>
#include <type_traits>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "../../Emplaceable.h"
#include "DefaultOnly.h"
#include "min_allocator.h"
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "../../Emplaceable.h"
#include "DefaultOnly.h"
#include "min_allocator.h"
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
struct TemplateConstructor
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
// node_type extract(const_iterator);
#include <set>
+#include "test_macros.h"
#include "min_allocator.h"
#include "Counter.h"
// node_type extract(key_type const&);
#include <set>
+#include "test_macros.h"
#include "min_allocator.h"
#include "Counter.h"
#include <set>
std::set<int> s;
#include <map>
+
+#include "test_macros.h"
using std::map;
using std::multimap;
#include <set>
+#include "test_macros.h"
+
struct A {
typedef std::set<A> Set;
int data;
// UNSUPPORTED: c++98, c++03
#include <set>
+#include "test_macros.h"
#include "container_test_types.h"
#include "../../set_allocator_requirement_test_templates.h"
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template<class Container>
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "min_allocator.h"
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "min_allocator.h"
#include <set>
#include <type_traits>
+#include "test_macros.h"
#include "min_allocator.h"
template <class Container>
// iterator insert(const_iterator hint, node_type&&);
#include <set>
+#include "test_macros.h"
#include "min_allocator.h"
template <class Container>
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "min_allocator.h"
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
int main(int, char**)
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "../../../test_compare.h"
int main(int, char**)
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "../../../test_compare.h"
#include "test_allocator.h"
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "../../../test_compare.h"
#include "test_allocator.h"
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "../../../test_compare.h"
#include "test_allocator.h"
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "../../../test_compare.h"
int main(int, char**)
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "min_allocator.h"
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "../../../test_compare.h"
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "../../../test_compare.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "../../../test_compare.h"
#include "test_allocator.h"
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "../../../test_compare.h"
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <set>
#include <type_traits>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
return c;
}
+#include "test_macros.h"
#include "test_allocator.h"
template <class T>
#include <queue>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include <cassert>
#include <functional>
+#include "test_macros.h"
+
template <class C>
C
make(int n)
#include <queue>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include <queue>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
int main(int, char**)
#include <cassert>
#include <functional>
+#include "test_macros.h"
+
template <class C>
C
make(int n)
#include <queue>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include <cassert>
#include <functional>
+#include "test_macros.h"
+
template <class C>
C
make(int n)
#include <queue>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
int main(int, char**)
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
int a[] = {3, 5, 2, 0, 6, 8, 1};
#include <functional>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
int a[] = {3, 5, 2, 0, 6, 8, 1};
#include <queue>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a[] = {3, 5, 2, 0, 6, 8, 1};
#include <queue>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
int main(int, char**)
#include <queue>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include <queue>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
int main(int, char**)
#include <queue>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
int main(int, char**)
#include <queue>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
int main(int, char**)
#include <queue>
#include <cassert>
+#include "test_macros.h"
#include "../../../Emplaceable.h"
int main(int, char**)
#include <queue>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::priority_queue<int> q;
#include <queue>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::priority_queue<int> q;
#include <queue>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::priority_queue<int> q;
#include <queue>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
int main(int, char**)
#include <queue>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::priority_queue<int> q;
#include <queue>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::priority_queue<int> q1;
#include <queue>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::priority_queue<int> q;
#include <queue>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::priority_queue<int> q1;
#include <utility>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
int main(int, char**)
#include <type_traits>
#include <vector>
+#include "test_macros.h"
+
struct test
: private std::priority_queue<int>
{
#include <queue>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
template <class C>
#include <queue>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "MoveOnly.h"
#include <queue>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "MoveOnly.h"
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
template <class C>
C
make(int n)
#include <queue>
#include <cassert>
+#include "test_macros.h"
+
template <class C>
C
make(int n)
#include <queue>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
int main(int, char**)
#include <queue>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include <queue>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include <queue>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
int main(int, char**)
#include <queue>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
int main(int, char**)
#include <queue>
#include <cassert>
+#include "test_macros.h"
+
template <class C>
C
make(int n)
#include <queue>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include <queue>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::queue<int> q;
#include <queue>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::queue<int> q;
#include <queue>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::queue<int> q;
#include <queue>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::queue<int> q;
#include <queue>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::queue<int> q;
#include <queue>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::queue<int> q;
#include <queue>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::queue<int> q;
#include <queue>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
int main(int, char**)
#include <queue>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::queue<int> q;
#include <queue>
#include <cassert>
+#include "test_macros.h"
+
template <class C>
C
make(int n)
#include <queue>
#include <type_traits>
+#include "test_macros.h"
+
struct test
: private std::queue<int>
{
#include <queue>
#include <cassert>
+#include "test_macros.h"
+
template <class C>
C
make(int n)
#include <queue>
#include <cassert>
+#include "test_macros.h"
+
template <class C>
C
make(int n)
#include <queue>
#include <cassert>
+#include "test_macros.h"
+
template <class C>
C
make(int n)
#include <utility>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
int main(int, char**)
#include <stack>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
template <class C>
#include <stack>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "MoveOnly.h"
#include <stack>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "MoveOnly.h"
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
template <class C>
C
make(int n)
#include <stack>
#include <cassert>
+#include "test_macros.h"
+
template <class C>
C
make(int n)
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
int main(int, char**)
#include <stack>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include <stack>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include <stack>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
int main(int, char**)
#include <stack>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
int main(int, char**)
#include <stack>
#include <cassert>
+#include "test_macros.h"
+
template <class C>
C
make(int n)
#include <stack>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include <stack>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::stack<int> q;
#include <stack>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::stack<int> q;
#include <stack>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::stack<int> q;
#include <stack>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
int main(int, char**)
#include <stack>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::stack<int> q;
#include <stack>
#include <cassert>
+#include "test_macros.h"
+
template <class C>
C
make(int n)
#include <stack>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::stack<int> q;
#include <stack>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::stack<int> q;
#include <vector>
#include <type_traits>
+#include "test_macros.h"
+
struct test
: private std::stack<int>
{
#include <stack>
#include <cassert>
+#include "test_macros.h"
+
template <class C>
C
make(int n)
#include <stack>
#include <cassert>
+#include "test_macros.h"
+
template <class C>
C
make(int n)
#include <stack>
#include <cassert>
+#include "test_macros.h"
+
template <class C>
C
make(int n)
#include <utility>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
int main(int, char**)
#include <unordered_map>
#include <set>
#include <map>
+#include "test_macros.h"
#include "min_allocator.h"
using namespace std;
// std::array is explicitly allowed to be initialized with A a = { init-list };.
// Disable the missing braces warning for this reason.
+#include "test_macros.h"
#include "disable_missing_braces_warning.h"
struct NoDefault {
// std::array is explicitly allowed to be initialized with A a = { init-list };.
// Disable the missing braces warning for this reason.
+#include "test_macros.h"
#include "disable_missing_braces_warning.h"
int main(int, char**)
// std::array is explicitly allowed to be initialized with A a = { init-list };.
// Disable the missing braces warning for this reason.
+#include "test_macros.h"
#include "disable_missing_braces_warning.h"
int main(int, char**)
// std::array is explicitly allowed to be initialized with A a = { init-list };.
// Disable the missing braces warning for this reason.
+#include "test_macros.h"
#include "disable_missing_braces_warning.h"
int main(int, char**)
#include <array>
#include <type_traits>
+#include "test_macros.h"
+
template <class T>
void test()
{
#include <array>
+#include "test_macros.h"
+
template <class T, std::size_t N>
void test()
{
#include <array>
+#include "test_macros.h"
+
int main(int, char**)
{
#include <array>
#include <cassert>
+#include "test_macros.h"
+
template <class C>
void test_contiguous ( const C &c )
{
#include <deque>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "../../../NotConstructible.h"
#include "min_allocator.h"
#include <deque>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <deque>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <deque>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "../../../NotConstructible.h"
#include "min_allocator.h"
#include <deque>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <deque>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <deque>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <deque>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <deque>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <deque>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
#include "min_allocator.h"
template <class T, class Allocator>
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
#include "../../../Emplaceable.h"
#include "min_allocator.h"
#include <deque>
#include <cassert>
+#include "test_macros.h"
+
template <typename C>
void del_at_start(C c)
{
#include <cstdint>
#include <cassert>
+#include "test_macros.h"
+
template <typename C>
void del_at_start(C c, size_t num)
{
#include <deque>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "min_allocator.h"
#include <deque>
#include <cassert>
+#include "test_macros.h"
+
template <typename C>
void test(C c)
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
#include "min_allocator.h"
template <class C>
#include <deque>
#include <cassert>
+#include "test_macros.h"
+
template <typename C>
void test(C c)
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
#include "min_allocator.h"
template <class C>
#include <deque>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class C>
// void push_back(const value_type& x);
#include <deque>
+#include "test_macros.h"
#include "test_allocator.h"
#include <cassert>
#include <deque>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "min_allocator.h"
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
#include "min_allocator.h"
template <class C>
#include <deque>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
// Flag that makes the copy constructor for CMyClass throw an exception
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "min_allocator.h"
#include <deque>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "min_allocator.h"
#include <deque>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "min_allocator.h"
#include <deque>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "min_allocator.h"
#include <deque>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "min_allocator.h"
#include <deque>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <iterator>
#include <type_traits>
+#include "test_macros.h"
#include "test_allocator.h"
#include "../../Copyable.h"
#include "min_allocator.h"
#include <cassert>
#include <iterator>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <forward_list>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "../../../NotConstructible.h"
#include "min_allocator.h"
#include <cassert>
#include <iterator>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <cassert>
#include <iterator>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <cassert>
#include <iterator>
+#include "test_macros.h"
#include "test_allocator.h"
#include "MoveOnly.h"
#include "min_allocator.h"
#include <cassert>
#include <iterator>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <cassert>
#include <iterator>
+#include "test_macros.h"
#include "test_iterators.h"
#include "min_allocator.h"
#include <cassert>
#include <iterator>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <cassert>
#include <iterator>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <forward_list>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <forward_list>
+#include "test_macros.h"
+
struct X
{
std::forward_list<X> q;
#include <forward_list>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <forward_list>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <cassert>
#include <iterator>
+#include "test_macros.h"
#include "test_allocator.h"
#include "MoveOnly.h"
#include "min_allocator.h"
#include <cassert>
#include <iterator>
+#include "test_macros.h"
#include "test_allocator.h"
#include "MoveOnly.h"
#include "min_allocator.h"
#include <cassert>
#include <iterator>
+#include "test_macros.h"
#include "test_iterators.h"
#include "min_allocator.h"
#include <cassert>
#include <iterator>
+#include "test_macros.h"
#include "test_allocator.h"
#include "test_iterators.h"
#include "min_allocator.h"
#include <forward_list>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <forward_list>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <cassert>
#include <iterator>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <forward_list>
#include <cassert>
+#include "test_macros.h"
#include "../../../Emplaceable.h"
#include "min_allocator.h"
#include <forward_list>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <forward_list>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <forward_list>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <forward_list>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <forward_list>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "min_allocator.h"
#include <forward_list>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "min_allocator.h"
#include <forward_list>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <forward_list>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "min_allocator.h"
#include <forward_list>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <forward_list>
#include <cassert>
+#include "test_macros.h"
+
// Flag that makes the copy constructor for CMyClass throw an exception
static bool gCopyConstructorShouldThow = false;
#include <forward_list>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "min_allocator.h"
#include <forward_list>
#include <cassert>
+#include "test_macros.h"
#include "DefaultOnly.h"
#include "min_allocator.h"
#include <iterator>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <functional>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <iterator>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
struct S {
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
#include "min_allocator.h"
#include "counting_predicates.hpp"
#include <algorithm>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class C>
#include <random>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
std::mt19937 randomness;
#include <cassert>
#include <iostream>
+#include "test_macros.h"
#include "min_allocator.h"
std::mt19937 randomness;
#include <iterator>
#include <cstddef>
+#include "test_macros.h"
#include "min_allocator.h"
typedef int T;
#include <cassert>
#include <iterator>
+#include "test_macros.h"
#include "min_allocator.h"
typedef ptrdiff_t T;
#include <iterator>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <iterator>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
struct PredLWG529 {
#include <forward_list>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <forward_list>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <forward_list>
#include <type_traits>
+#include "test_macros.h"
#include "min_allocator.h"
struct A { std::forward_list<A> v; }; // incomplete type support
#include <list>
+#include "test_macros.h"
+
struct A {
std::list<A> l;
std::list<A>::iterator it;
#include <list>
#include <cassert>
+#include "test_macros.h"
#include "DefaultOnly.h"
#include "min_allocator.h"
#include <list>
#include <cassert>
+#include "test_macros.h"
#include "DefaultOnly.h"
#include "min_allocator.h"
#include <list>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <list>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <list>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <list>
#include <cassert>
+#include "test_macros.h"
#include "DefaultOnly.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <list>
#include <cassert>
+#include "test_macros.h"
#include "DefaultOnly.h"
#include "min_allocator.h"
#include <list>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <list>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <list>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <list>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <list>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <list>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <list>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <list>
#include <cassert>
+#include "test_macros.h"
#include "DefaultOnly.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <list>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
class A
#include <list>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <list>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <list>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <list>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "min_allocator.h"
#include <list>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <list>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <list>
#include <cassert>
+#include "test_macros.h"
+
// Flag that makes the copy constructor for CMyClass throw an exception
static bool gCopyConstructorShouldThow = false;
#include <list>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "min_allocator.h"
#include <list>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <list>
#include <cassert>
+#include "test_macros.h"
+
// Flag that makes the copy constructor for CMyClass throw an exception
static bool gCopyConstructorShouldThow = false;
#include <list>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "min_allocator.h"
#include <list>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <functional>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <cassert>
#include <functional>
+#include "test_macros.h"
#include "min_allocator.h"
#include "counting_predicates.hpp"
#include <list>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
std::mt19937 randomness;
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
std::mt19937 randomness;
#include <list>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <list>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
bool g(int x, int y)
#include <list>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <list>
#include <type_traits>
+#include "test_macros.h"
#include "min_allocator.h"
struct A { std::list<A> v; }; // incomplete type support
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <vector>
#include "poisoned_hash_helper.hpp"
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**) {
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <iterator>
#include <type_traits>
+#include "test_macros.h"
#include "test_allocator.h"
#include "../../Copyable.h"
#include "min_allocator.h"
#include <cassert>
#include <type_traits>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <iterator>
#include <type_traits>
+#include "test_macros.h"
#include "test_allocator.h"
#include "../../Copyable.h"
#include "min_allocator.h"
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
#include "asan_testing.h"
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include "asan_testing.h"
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include "asan_testing.h"
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include "asan_testing.h"
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
#include "asan_testing.h"
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
#include "asan_testing.h"
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <algorithm>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
#include "asan_testing.h"
#include <vector>
+#include "test_macros.h"
+
struct X
{
std::vector<X> q;
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
#include "asan_testing.h"
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include "asan_testing.h"
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "test_allocator.h"
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "test_allocator.h"
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
#include "asan_testing.h"
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
#include "asan_testing.h"
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
#include "asan_testing.h"
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
#include "asan_testing.h"
#include <iterator>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
#include "asan_testing.h"
#include <iterator>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
#include "asan_testing.h"
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
#include "asan_testing.h"
#include <vector>
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include "asan_testing.h"
#include <vector>
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <vector>
#include <iterator>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include "asan_testing.h"
#include <unordered_map>
#include <cassert>
+#include "test_macros.h"
+
struct Key {
template <typename T> Key(const T&) {}
bool operator== (const Key&) const { return true; }
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <unordered_map>
+#include "test_macros.h"
+
template <class Tp>
struct MyHash {
MyHash() {}
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <unordered_map>
#include <type_traits>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <cmath>
#include <cstddef>
+#include "test_macros.h"
#include "../../../test_compare.h"
#include "../../../test_hash.h"
#include "min_allocator.h"
#include <unordered_map>
#include <tuple>
+#include "test_macros.h"
+
using namespace std;
struct my_hash
#include <unordered_map>
#include <cassert>
+#include "test_macros.h"
#include "../../../Emplaceable.h"
#include "min_allocator.h"
#include <unordered_map>
#include <cassert>
+#include "test_macros.h"
#include "../../../Emplaceable.h"
#include "min_allocator.h"
#include <unordered_map>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cstdlib>
#include <exception>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
// node_type extract(const_iterator);
#include <unordered_map>
+#include "test_macros.h"
#include "min_allocator.h"
#include "Counter.h"
// node_type extract(key_type const&);
#include <unordered_map>
+#include "test_macros.h"
#include "min_allocator.h"
#include "Counter.h"
#include <unordered_map>
+#include "test_macros.h"
#include "container_test_types.h"
#include "../../../map_allocator_requirement_test_templates.h"
#include <unordered_map>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template<class Container>
#include <unordered_map>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "min_allocator.h"
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "min_allocator.h"
// insert_return_type insert(node_type&&);
#include <unordered_map>
+#include "test_macros.h"
#include "min_allocator.h"
template <class Container>
// iterator insert(const_iterator hint, node_type&&);
#include <unordered_map>
+#include "test_macros.h"
#include "min_allocator.h"
template <class Container>
#include <cassert>
#include <tuple>
+#include "test_macros.h"
+
class Moveable
{
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "min_allocator.h"
#include <unordered_map>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "min_allocator.h"
#include <cassert>
#include <tuple>
+#include "test_macros.h"
+
class Moveable
{
Moveable(const Moveable&);
#include <unordered_map>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
#if _LIBCPP_DEBUG >= 1
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <unordered_map>
+#include "test_macros.h"
+
template <class Tp>
struct MyHash {
MyHash() {}
#include <cfloat>
#include <cmath>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <unordered_map>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::unordered_map<int, int> M1;
#include <unordered_map>
#include <type_traits>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <cmath>
#include <cstddef>
+#include "test_macros.h"
#include "../../../check_consecutive.h"
#include "../../../test_compare.h"
#include "../../../test_hash.h"
#include <unordered_map>
#include <cassert>
+#include "test_macros.h"
#include "../../../Emplaceable.h"
#include "min_allocator.h"
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
#include "../../../check_consecutive.h"
#include "min_allocator.h"
#include <unordered_map>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cstdlib>
#include <exception>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
#include "../../../check_consecutive.h"
#include "min_allocator.h"
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
#include "../../../check_consecutive.h"
#include "min_allocator.h"
// node_type extract(const_iterator);
#include <unordered_map>
+#include "test_macros.h"
#include "min_allocator.h"
#include "Counter.h"
// node_type extract(key_type const&);
#include <unordered_map>
+#include "test_macros.h"
#include "min_allocator.h"
#include "Counter.h"
#include <unordered_map>
+#include "test_macros.h"
#include "container_test_types.h"
#include "../../../map_allocator_requirement_test_templates.h"
#include <unordered_map>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template<class Container>
#include <unordered_map>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template<class Container>
#include <unordered_map>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "min_allocator.h"
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
#include "../../../check_consecutive.h"
#include "test_iterators.h"
#include "min_allocator.h"
// iterator insert(node_type&&);
#include <unordered_map>
+#include "test_macros.h"
#include "min_allocator.h"
template <class Container>
// iterator insert(const_iterator hint, node_type&&);
#include <unordered_map>
+#include "test_macros.h"
#include "min_allocator.h"
template <class Container>
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
#include "../../../check_consecutive.h"
#include "test_iterators.h"
#include "min_allocator.h"
#include <unordered_map>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "min_allocator.h"
#include <unordered_map>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
#if _LIBCPP_DEBUG >= 1
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
#include "../../Emplaceable.h"
#include "min_allocator.h"
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
#include "../../Emplaceable.h"
#include "min_allocator.h"
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
struct TemplateConstructor
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cstdlib>
#include <exception>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
#if TEST_STD_VER >= 11
#include <cassert>
#include <iterator>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
// node_type extract(const_iterator);
#include <unordered_set>
+#include "test_macros.h"
#include "min_allocator.h"
#include "Counter.h"
// node_type extract(key_type const&);
#include <unordered_set>
+#include "test_macros.h"
#include "min_allocator.h"
#include "Counter.h"
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <unordered_set>
+#include "test_macros.h"
+
template <class Tp>
struct MyHash {
MyHash() {}
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template<class Container>
// UNSUPPORTED: c++98, c++03
#include <unordered_set>
+#include "test_macros.h"
#include "container_test_types.h"
#include "../../set_allocator_requirement_test_templates.h"
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template<class Container>
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "min_allocator.h"
#include <unordered_set>
#include <type_traits>
+#include "test_macros.h"
#include "min_allocator.h"
template <class Container>
// iterator insert(const_iterator hint, node_type&&);
#include <unordered_set>
+#include "test_macros.h"
#include "min_allocator.h"
template <class Container>
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "min_allocator.h"
#include <cfloat>
#include <cmath>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <unordered_set>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::unordered_set<int> M1;
#include <unordered_set>
#include <type_traits>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <cmath>
#include <cstddef>
+#include "test_macros.h"
#include "../../../test_compare.h"
#include "../../../test_hash.h"
#include "test_allocator.h"
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
#if _LIBCPP_DEBUG >= 1
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
#include "../../Emplaceable.h"
#include "min_allocator.h"
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
#include "../../Emplaceable.h"
#include "min_allocator.h"
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
struct TemplateConstructor
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cstdlib>
#include <exception>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
#if TEST_STD_VER >= 11
#include <algorithm>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
// node_type extract(const_iterator);
#include <unordered_set>
+#include "test_macros.h"
#include "min_allocator.h"
#include "Counter.h"
// node_type extract(key_type const&);
#include <unordered_set>
+#include "test_macros.h"
#include "min_allocator.h"
#include "Counter.h"
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <unordered_set>
+#include "test_macros.h"
+
template <class Tp>
struct MyHash {
MyHash() {}
#include <unordered_set>
+#include "test_macros.h"
#include "container_test_types.h"
#include "../../set_allocator_requirement_test_templates.h"
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template<class Container>
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template<class Container>
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "min_allocator.h"
#include <unordered_set>
#include <type_traits>
+#include "test_macros.h"
#include "min_allocator.h"
template <class Container>
// iterator insert(const_iterator hint, node_type&&);
#include <unordered_set>
+#include "test_macros.h"
#include "min_allocator.h"
template <class Container>
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "min_allocator.h"
#include <cfloat>
#include <cmath>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <unordered_set>
#include <type_traits>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <cmath>
#include <cstddef>
+#include "test_macros.h"
#include "../../../test_compare.h"
#include "../../../test_hash.h"
#include "test_allocator.h"
#include <cmath>
#include <cstddef>
+#include "test_macros.h"
#include "../../../test_compare.h"
#include "../../../test_hash.h"
#include "test_allocator.h"
#include <unordered_set>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
#if _LIBCPP_DEBUG >= 1
#include <span>
+#include "test_macros.h"
+
template <class T, std::size_t N>
void test()
{
#include <memory>
#include <cassert>
+#include "test_macros.h"
#include "../A.h"
void
#include <memory>
#include <cassert>
+#include "test_macros.h"
#include "../AB.h"
void
#include <memory>
#include <cassert>
+#include "test_macros.h"
#include "../AB.h"
void
#include <memory>
#include <cassert>
+#include "test_macros.h"
#include "../A.h"
void
#include <memory>
#include <cassert>
+#include "test_macros.h"
#include "../A.h"
void
#include <memory>
#include <cassert>
+#include "test_macros.h"
#include "../A.h"
void
#include <memory>
#include <cassert>
+#include "test_macros.h"
#include "../AB.h"
void
#include <memory>
#include <cassert>
+#include "test_macros.h"
#include "../AB.h"
std::auto_ptr<B>
#include <memory>
#include <cassert>
+#include "test_macros.h"
#include "../AB.h"
void
#include <memory>
#include <cassert>
+#include "test_macros.h"
#include "../A.h"
void
#include <memory>
#include <cassert>
+#include "test_macros.h"
#include "../A.h"
void
#include <memory>
#include <cassert>
+#include "test_macros.h"
#include "../A.h"
void
#include <memory>
#include <cassert>
+#include "test_macros.h"
#include "../A.h"
void
#include <memory>
#include <type_traits>
+#include "test_macros.h"
+
template <class T>
void
test()
#include <assert.h>
+#include "test_macros.h"
+
#ifndef assert
#error assert not defined
#endif
#include <ciso646>
+#include "test_macros.h"
+
int main(int, char**)
{
#include <complex.h>
+#include "test_macros.h"
+
int main(int, char**)
{
std::complex<double> d;
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
#ifdef isalnum
#error isalnum defined
#endif
#include <errno.h>
+#include "test_macros.h"
+
#ifndef EDOM
#error EDOM not defined
#endif
#include <fenv.h>
#include <type_traits>
+#include "test_macros.h"
+
#ifndef FE_DIVBYZERO
#error FE_DIVBYZERO not defined
#endif
#include <inttypes.h>
#include <type_traits>
+#include "test_macros.h"
+
#ifndef INT8_MIN
#error INT8_MIN not defined
#endif
#include <iso646.h>
+#include "test_macros.h"
+
int main(int, char**)
{
// Nothing to test
#include <limits.h>
+#include "test_macros.h"
+
#ifndef CHAR_BIT
#error CHAR_BIT not defined
#endif
#include <locale.h>
#include <type_traits>
+#include "test_macros.h"
+
#ifndef LC_ALL
#error LC_ALL not defined
#endif
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
#include "hexfloat.h"
#include "truncate_fp.h"
#include <setjmp.h>
#include <type_traits>
+#include "test_macros.h"
+
#ifndef setjmp
#error setjmp not defined
#endif
#include <signal.h>
#include <type_traits>
+#include "test_macros.h"
+
#ifndef SIG_DFL
#error SIG_DFL not defined
#endif
#include <stdbool.h>
+#include "test_macros.h"
+
#ifndef __bool_true_false_are_defined
#error __bool_true_false_are_defined not defined
#endif
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
// typedef int8_t
#include <string.h>
#include <type_traits>
+#include "test_macros.h"
+
#ifndef NULL
#error NULL not defined
#endif
#include <tgmath.h>
+#include "test_macros.h"
+
int main(int, char**)
{
std::complex<double> cd;
#include <time.h>
#include <type_traits>
+#include "test_macros.h"
+
#ifndef NULL
#error NULL not defined
#endif
#include <stdarg.h>
#include <type_traits>
+#include "test_macros.h"
+
#ifndef NULL
#error NULL not defined
#endif
#include <wctype.h>
#include <type_traits>
+#include "test_macros.h"
+
#ifndef WEOF
#error WEOF not defined
#endif
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
double binary_f(int i, short j) {return i - j + .75;}
int main(int, char**)
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
double unary_f(int i) {return 0.5 - i;}
int main(int, char**)
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
double unary_f(int i) {return 0.5 - i;}
int main(int, char**)
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
double binary_f(int i, short j) {return i - j + .75;}
int main(int, char**)
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
char a1() {return 5;}
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
char a1() {return 5;}
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
char a1() {return 5;}
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
char a1() {return 5;}
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
char a1() {return 5;}
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
char a1() {return 5;}
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
char a1() {return 5;}
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
char a1() {return 5;}
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
char a1() {return 5;}
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
char a1() {return 5;}
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
char a1() {return 5;}
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
char a1() {return 5;}
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
char a1() {return 5;}
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
char a1() {return 5;}
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
char a1() {return 5;}
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
char a1() {return 5;}
#include <functional>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_same<std::binary_function<int, unsigned, char>::first_argument_type, int>::value), "");
#include <functional>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_same<std::unary_function<unsigned, char>::argument_type, unsigned>::value), "");
#include <functional>
#include <cassert>
+#include "test_macros.h"
#include "../test_func.h"
int main(int, char**)
#include <functional>
#include <cassert>
+#include "test_macros.h"
#include "../test_func.h"
int main(int, char**)
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
#include "../test_func.h"
class test
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
#include "../test_func.h"
class test
#include <cassert>
#include <string>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <string>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <string>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <string>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <strstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <strstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <strstream>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::istream, std::istrstream>::value), "");
#include <cassert>
#include <string>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <string>
+#include "test_macros.h"
+
int main(int, char**)
{
std::ostrstream out;
#include <strstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <strstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <strstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <strstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <strstream>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::ostream, std::ostrstream>::value), "");
#include <cassert>
#include <string>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cstring>
#include <string>
+#include "test_macros.h"
+
int main(int, char**)
{
std::strstream inout;
#include <strstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <strstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <strstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <strstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <strstream>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::iostream, std::strstream>::value), "");
#include <strstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstring>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <strstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <strstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <strstream>
#include <cassert>
+#include "test_macros.h"
+
int called = 0;
void* my_alloc(std::size_t)
#include <strstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstring>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstring>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <strstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <string>
#include <strstream>
+#include "test_macros.h"
+
int main(int, char**) {
std::ostrstream oss;
std::string s;
#include <strstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <strstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <strstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <strstream>
#include <cassert>
+#include "test_macros.h"
+
struct test
: public std::strstreambuf
{
#include <strstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <strstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <strstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <strstream>
#include <cassert>
+#include "test_macros.h"
+
struct test
: public std::strstreambuf
{
#include <strstream>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::streambuf, std::strstreambuf>::value), "");
#include <cassert>
#include <cstdlib>
+#include "test_macros.h"
+
void f1() {}
void f2() {}
#include <cassert>
#include <cstdlib>
+#include "test_macros.h"
+
void f1() {}
void f2() {}
#include <exception>
+#include "test_macros.h"
+
void f() {}
int main(int, char**)
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
void f1()
{
std::exit(0);
#include <cassert>
+#include "test_macros.h"
+
#ifndef assert
#error assert not defined
#endif
#include <cerrno>
+#include "test_macros.h"
+
#ifndef E2BIG
#error E2BIG not defined
#endif
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::logic_error, std::domain_error>::value),
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::logic_error, std::invalid_argument>::value),
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::logic_error, std::length_error>::value),
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::exception, std::logic_error>::value),
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::logic_error, std::out_of_range>::value),
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::runtime_error, std::overflow_error>::value),
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::runtime_error, std::range_error>::value),
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::exception, std::runtime_error>::value),
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::runtime_error, std::underflow_error>::value),
#include <system_error>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert(static_cast<int>(std::errc::address_family_not_supported) == EAFNOSUPPORT, "");
#include <system_error>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::error_code e_code1(5, std::generic_category());
#include <stdio.h>
+#include "test_macros.h"
+
int main(int, char**)
{
const std::error_category& e_cat1 = std::generic_category();
#include <string>
#include <cassert>
+#include "test_macros.h"
+
class test1
: public std::error_category
{
#include <system_error>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
const std::error_category& e_cat1 = std::generic_category();
#include <system_error>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
const std::error_category& e_cat1 = std::generic_category();
#include <system_error>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
const std::error_category& e_cat1 = std::generic_category();
#include <system_error>
+#include "test_macros.h"
+
int main(int, char**)
{
std::error_category* p = 0;
#include <system_error>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
const std::error_category& e_cat = std::generic_category();
#include <system_error>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
const std::error_category& e_cat = std::generic_category();
#include <system_error>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
const std::error_category& e_cat = std::generic_category();
#include <system_error>
#include <cassert>
+#include "test_macros.h"
+
enum testing
{
zero, one, two
#include <system_error>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::error_code ec;
#include <system_error>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <system_error>
#include <cassert>
+#include "test_macros.h"
+
enum testing
{
zero, one, two
#include <system_error>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <system_error>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <system_error>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::ostringstream out;
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <system_error>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
const std::error_code ec(6, std::generic_category());
#include <system_error>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
const std::error_code ec(6, std::generic_category());
#include <system_error>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
const std::error_code ec(6, std::system_category());
#include <system_error>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <system_error>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::error_condition ec;
#include <system_error>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <system_error>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <system_error>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <system_error>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <system_error>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <system_error>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
const std::error_condition ec(6, std::generic_category());
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
const std::error_condition ec(6, std::generic_category());
#include <system_error>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
const std::error_condition ec(6, std::system_category());
#include "poisoned_hash_helper.hpp"
+#include "test_macros.h"
+
int main(int, char**) {
test_library_hash_specializations_available();
{
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::system_error se(static_cast<int>(std::errc::not_a_directory),
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::string what_arg("test message");
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::string what_arg("test message");
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::system_error se(static_cast<int>(std::errc::not_a_directory),
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::string what_arg("test message");
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::string what_arg("test message");
#include <experimental/algorithm>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
int searcher_called = 0;
#include <experimental/filesystem>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**) {
static_assert(std::is_same<
std::experimental::filesystem::path,
#include <experimental/functional>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <typename Iter1, typename Iter2>
#include <experimental/functional>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <typename T> struct MyHash {
#include <experimental/functional>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <typename T> struct MyHash {
#include <experimental/functional>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
struct count_equal
#include <experimental/functional>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <typename Iter1, typename Iter2>
#include <experimental/functional>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <typename T> struct MyHash {
#include <experimental/functional>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <typename T> struct MyHash {
#include <experimental/functional>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
struct count_equal
#include <experimental/functional>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <typename Iter1, typename Iter2>
#include <experimental/functional>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
struct count_equal
#include <experimental/functional>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <typename Iter1, typename Iter2>
#include <experimental/functional>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
struct count_equal
#include <experimental/functional>
+#include "test_macros.h"
+
int main(int, char**)
{
std::function<int(int)> x;
#include <experimental/iterator>
+#include "test_macros.h"
+
int main(int, char**) {
return 0;
}
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
namespace coro = std::experimental;
template <class C>
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
namespace coro = std::experimental;
template <class C>
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
namespace coro = std::experimental;
template <class C>
#include <cassert>
#include <type_traits>
+#include "test_macros.h"
+
#if __has_builtin(__builtin_coro_noop)
namespace coro = std::experimental::coroutines_v1;
#include <experimental/coroutine>
+#include "test_macros.h"
+
namespace coro = std::experimental;
struct A {
#include <experimental/coroutine>
+#include "test_macros.h"
+
namespace coro = std::experimental;
template <class T, class = typename T::promise_type>
#include <experimental/coroutine>
#include <cassert>
+#include "test_macros.h"
+
using namespace std::experimental;
struct coro_t {
#include <experimental/coroutine>
#include <cassert>
+#include "test_macros.h"
+
using namespace std::experimental;
struct coro_t {
#include <experimental/coroutine>
#include <cassert>
+
+#include "test_macros.h"
using namespace std::experimental;
struct error {};
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "coroutine_types.h"
using namespace std::experimental;
#include <experimental/coroutine>
#include <cassert>
+#include "test_macros.h"
+
using namespace std::experimental;
bool cancel = false;
#include <experimental/coroutine>
#include <cassert>
+#include "test_macros.h"
+
using namespace std::experimental;
// This file tests, multishot, movable std::function like thing using coroutine
#include <vector>
#include <cassert>
+#include "test_macros.h"
+
using namespace std::experimental;
// This file tests, one shot, movable std::function like thing using coroutine
// std::nothrow is not implicitly defined by the compiler when the include is
// missing, unlike other parts of <new>. Therefore we use std::nothrow to
// test for #include <new>
+
(void)std::nothrow;
return 0;
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
namespace ex = std::experimental::pmr;
int main(int, char**)
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
namespace ex = std::experimental::pmr;
int main(int, char**)
#include "test_memory_resource.hpp"
+#include "test_macros.h"
+
namespace ex = std::experimental::pmr;
int main(int, char**)
#include "test_memory_resource.hpp"
+#include "test_macros.h"
+
namespace ex = std::experimental::pmr;
int main(int, char**)
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
namespace ex = std::experimental::pmr;
int main(int, char**)
#include "test_memory_resource.hpp"
+#include "test_macros.h"
+
namespace ex = std::experimental::pmr;
int main(int, char**)
#include "test_memory_resource.hpp"
+#include "test_macros.h"
+
namespace ex = std::experimental::pmr;
int main(int, char**)
#include <cstdlib>
#include "uses_alloc_types.hpp"
+#include "test_macros.h"
+
namespace ex = std::experimental::pmr;
int constructed = 0;
#include "test_memory_resource.hpp"
+#include "test_macros.h"
+
namespace ex = std::experimental::pmr;
template <size_t S, size_t Align>
#include <cassert>
#include <cstdlib>
+#include "test_macros.h"
+
namespace ex = std::experimental::pmr;
int count = 0;
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
namespace ex = std::experimental::pmr;
int main(int, char**)
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
namespace ex = std::experimental::pmr;
int main(int, char**)
#include "test_memory_resource.hpp"
+#include "test_macros.h"
+
namespace ex = std::experimental::pmr;
int main(int, char**)
#include "test_memory_resource.hpp"
+#include "test_macros.h"
+
namespace ex = std::experimental::pmr;
int main(int, char**)
#include "test_memory_resource.hpp"
+#include "test_macros.h"
+
namespace ex = std::experimental::pmr;
int main(int, char**)
#include <cassert>
#include "test_memory_resource.hpp"
+#include "test_macros.h"
+
using std::size_t;
namespace ex = std::experimental::pmr;
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
namespace ex = std::experimental::pmr;
int main(int, char**)
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
namespace pmr = std::experimental::pmr;
int main(int, char**)
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
namespace pmr = std::experimental::pmr;
int main(int, char**)
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
namespace pmr = std::experimental::pmr;
int main(int, char**)
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
namespace pmr = std::experimental::pmr;
int main(int, char**)
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
namespace pmr = std::experimental::pmr;
template <class Iter, class PmrTypedef>
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
namespace pmr = std::experimental::pmr;
int main(int, char**)
#include "constexpr_char_traits.hpp"
+#include "test_macros.h"
+
namespace pmr = std::experimental::pmr;
template <class Char, class PmrTypedef>
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
namespace pmr = std::experimental::pmr;
template <class T>
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
namespace pmr = std::experimental::pmr;
template <class T>
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
namespace pmr = std::experimental::pmr;
int main(int, char**)
#include "test_memory_resource.hpp"
+#include "test_macros.h"
+
using namespace std::experimental::pmr;
int main(int, char**) {
#include "count_new.hpp"
+#include "test_macros.h"
+
namespace ex = std::experimental::pmr;
struct assert_on_compare : public ex::memory_resource
#include "test_memory_resource.hpp"
+#include "test_macros.h"
+
namespace ex = std::experimental::pmr;
int main(int, char**)
#include "test_memory_resource.hpp"
+#include "test_macros.h"
+
using std::experimental::pmr::memory_resource;
int main(int, char**)
#include "test_memory_resource.hpp"
+#include "test_macros.h"
+
using std::experimental::pmr::memory_resource;
int main(int, char**)
#include <cassert>
#include "test_memory_resource.hpp"
+#include "test_macros.h"
+
using std::experimental::pmr::memory_resource;
int main(int, char**)
#include <experimental/simd>
#include <cstdint>
+#include "test_macros.h"
+
namespace ex = std::experimental::parallelism_v2;
constexpr inline int reg_width() {
#include <cassert>
#include <cstdint>
+#include "test_macros.h"
+
namespace ex = std::experimental::parallelism_v2;
template <typename SimdType>
#include <experimental/simd>
#include <cstdint>
+#include "test_macros.h"
+
namespace ex = std::experimental::parallelism_v2;
static_assert(
#include <experimental/simd>
#include <cstdint>
+#include "test_macros.h"
+
namespace ex = std::experimental::parallelism_v2;
static_assert(
#include <cstdint>
#include <experimental/simd>
+#include "test_macros.h"
+
namespace ex = std::experimental::parallelism_v2;
template <class T, class... Args>
#include <cstdint>
#include <experimental/simd>
+#include "test_macros.h"
+
namespace ex = std::experimental::parallelism_v2;
int main(int, char**) {
#include <experimental/simd>
#include <cstdint>
+#include "test_macros.h"
+
namespace ex = std::experimental::parallelism_v2;
template <class T, class... Args>
#include <cstdint>
#include <experimental/simd>
+#include "test_macros.h"
+
namespace ex = std::experimental::parallelism_v2;
static_assert(std::is_same<typename ex::abi_for_size<int, 4>::type,
// template <class U> propagate_const& propagate_const::operator=(const propagate_const<U>&)=delete;
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <type_traits>
// template <class U> propagate_const& propagate_const::operator=(U&&);
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <cassert>
// template <class U> constexpr propagate_const& operator=(U&& u); // won't bind to propagate_const
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <type_traits>
// template <class U> propagate_const& propagate_const::operator=(U&&);
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <cassert>
// template <class U> propagate_const& propagate_const::operator=(propagate_const<U>&&);
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <cassert>
// template <class U> propagate_const& propagate_const::operator=(propagate_const<U>&&);
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <cassert>
// template <class U> constexpr propagate_const& operator=(propagate_const<_Up>&& pu);
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <cassert>
// template <class U> constexpr propagate_const& operator=(propagate_const<_Up>&& pu);
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <type_traits>
// template <class U> constexpr propagate_const(propagate_const<_Up>&& pu);
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <cassert>
// template <class U> constexpr propagate_const& operator(propagate_const<_Up>&& pu);
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <type_traits>
// template <class U> constexpr propagate_const(propagate_const<_Up>&& pu);
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <type_traits>
// template <class U> constexpr propagate_const(propagate_const<_Up>&& pu);
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <cassert>
// propagate_const(const propagate_const&)=delete;
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <type_traits>
// template <class U> propagate_const(U&&);
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <type_traits>
// template <class U> propagate_const(U&&);
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <cassert>
// propagate_const(propagate_const&&)=default;
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <cassert>
// element_type& propagate_const::operator*();
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <cassert>
// propagate_const::operator element_type*();
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <type_traits>
// element_type* propagate_const::get();
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <cassert>
// element_type* propagate_const::operator->();
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <cassert>
// propagate_const::operator element_type*();
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <cassert>
// const element_type& propagate_const::operator*() const;
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <cassert>
// propagate_const::operator const element_type*() const;
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <type_traits>
// const element_type* propagate_const::get() const;
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <cassert>
// const element_type* propagate_const::operator->() const;
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <cassert>
// propagate_const::operator const element_type*() const;
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <cassert>
// template <class T> constexpr void propagate_const::swap(propagate_const<T>& x);
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <cassert>
// template <class T> struct hash<experimental::fundamentals_v2::propagate_const<T>>;
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <cassert>
// template <class T> struct equal_to<experimental::fundamentals_v2::propagate_const<T>>;
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <cassert>
// template <class T> struct greater<experimental::fundamentals_v2::propagate_const<T>>;
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <cassert>
// template <class T> struct greater_equal<experimental::fundamentals_v2::propagate_const<T>>;
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <cassert>
// template <class T> struct less<experimental::fundamentals_v2::propagate_const<T>>;
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <cassert>
// template <class T> struct less_equal<experimental::fundamentals_v2::propagate_const<T>>;
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <cassert>
// template <class T> struct not_equal_to<experimental::fundamentals_v2::propagate_const<T>>;
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <cassert>
// template <class T> constexpr bool operator==(const propagate_const<T>& x, const T& y);
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <cassert>
// template <class T> constexpr bool operator>=(const propagate_const<T>& x, const T& y);
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <cassert>
// template <class T> constexpr bool operator>(const propagate_const<T>& x, const T& y);
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <cassert>
// template <class T> constexpr bool operator<=(const propagate_const<T>& x, const T& y);
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <cassert>
// template <class T> constexpr bool operator<(const propagate_const<T>& x, const T& y);
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <cassert>
// template <class T> constexpr bool operator!=(const propagate_const<T>& x, const T& y);
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <cassert>
// template <class T> constexpr void swap(propagate_const<T>& x, propagate_const<T>& y);
#include <experimental/propagate_const>
+#include "test_macros.h"
#include "propagate_const_helpers.h"
#include <cassert>
#include <experimental/utility>
+#include "test_macros.h"
+
int main(int, char**)
{
std::experimental::erased_type e;
#include <experimental/utility>
+#include "test_macros.h"
+
#ifndef _LIBCPP_UTILITY
# error "<experimental/utility> must include <utility>"
#endif
#include <cinttypes>
#include <type_traits>
+#include "test_macros.h"
+
#ifndef INT8_MIN
#error INT8_MIN not defined
#endif
#include <fstream>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
int main(int, char**)
#include <fstream>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
int main(int, char**)
#include <fstream>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
int main(int, char**)
#include <fstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <fstream>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
int main(int, char**)
#include <fstream>
#include <filesystem>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
namespace fs = std::filesystem;
#include <fstream>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
int main(int, char**)
#include <fstream>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
template <class CharT>
#include <cstddef>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
template <class CharT>
#include <fstream>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::basic_streambuf<char>, std::basic_filebuf<char> >::value), "");
#include <fstream>
#include <utility>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
std::pair<std::string, std::string> get_temp_file_names() {
#include <fstream>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
int main(int, char**)
#include <fstream>
#include <utility>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
#include <fstream>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <fstream>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
int main(int, char**)
#include <fstream>
#include <filesystem>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
namespace fs = std::filesystem;
#include <fstream>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
int main(int, char**)
#include <fstream>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
int main(int, char**)
#include <fstream>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
int main(int, char**)
#include <fstream>
#include <filesystem>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
int main(int, char**) {
#include <fstream>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
int main(int, char**)
#include <fstream>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
int main(int, char**)
#include <fstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <fstream>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::basic_iostream<char>, std::basic_fstream<char> >::value), "");
#include <fstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <fstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <fstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <fstream>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <fstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <filesystem>
#include <cassert>
+#include "test_macros.h"
+
namespace fs = std::filesystem;
int main(int, char**) {
#include <fstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <fstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <fstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <filesystem>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**) {
{
std::ifstream fs;
#include <fstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <fstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <fstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <fstream>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::basic_istream<char>, std::basic_ifstream<char> >::value), "");
#include <fstream>
#include <utility>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
std::pair<std::string, std::string> get_temp_file_names() {
#include <fstream>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
int main(int, char**)
#include <fstream>
#include <utility>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
std::pair<std::string, std::string> get_temp_file_names() {
#include <fstream>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <fstream>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
int main(int, char**)
#include <fstream>
#include <filesystem>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
namespace fs = std::filesystem;
#include <fstream>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
int main(int, char**)
#include <fstream>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
int main(int, char**)
#include <fstream>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
int main(int, char**)
#include <fstream>
#include <filesystem>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
namespace fs = std::filesystem;
#include <fstream>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
int main(int, char**)
#include <fstream>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
int main(int, char**)
#include <fstream>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
int main(int, char**)
#include <fstream>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::basic_ostream<char>, std::basic_ofstream<char> >::value), "");
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**) {
using namespace fs;
// Default
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**) {
using namespace fs;
// Default
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
#define CHECK_OP(Op) \
static_assert(std::is_same<decltype(ce. operator Op (ce)), bool>::value, ""); \
#include <iostream>
+#include "test_macros.h"
+
TEST_SUITE(directory_entry_obs_testsuite)
TEST_CASE(signatures) {
#include "filesystem_test_helper.hpp"
#include "rapid-cxx-test.hpp"
+#include "test_macros.h"
+
TEST_SUITE(directory_entry_obs_testsuite)
TEST_CASE(file_dne) {
#include "filesystem_test_helper.hpp"
#include "rapid-cxx-test.hpp"
+#include "test_macros.h"
+
TEST_SUITE(directory_entry_obs_testsuite)
TEST_CASE(signatures) {
#include "filesystem_test_helper.hpp"
#include "rapid-cxx-test.hpp"
+#include "test_macros.h"
+
TEST_SUITE(directory_entry_obs_testsuite)
TEST_CASE(signatures) {
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
void test_path_method() {
using namespace fs;
#include "filesystem_test_helper.hpp"
#include "rapid-cxx-test.hpp"
+#include "test_macros.h"
+
TEST_SUITE(directory_entry_status_testsuite)
TEST_CASE(test_basic) {
#include "filesystem_test_helper.hpp"
#include "rapid-cxx-test.hpp"
+#include "test_macros.h"
+
TEST_SUITE(directory_entry_obs_suite)
TEST_CASE(test_signature) {
#include "test_convertible.hpp"
+#include "test_macros.h"
+
int main(int, char**) {
using namespace fs;
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**) {
using namespace fs;
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**) {
using namespace fs;
#include <filesystem>
#include <type_traits>
+#include "test_macros.h"
+
using namespace std::filesystem;
int main(int, char**) {
#include <istream>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
template <class CharT>
#include <istream>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
template <class CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
template <class CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
template <class CharT>
#include <istream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
struct testbuf
: public std::basic_streambuf<CharT>
#include <istream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
struct testbuf
#include <istream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
struct testbuf
#include <istream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
struct testbuf
: public std::basic_streambuf<CharT>
#include <istream>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::basic_istream<char>, std::basic_iostream<char> >::value), "");
#include <istream>
#include <cassert>
+#include "test_macros.h"
+
int f_called = 0;
template <class CharT>
#include <istream>
#include <cassert>
+#include "test_macros.h"
+
int f_called = 0;
std::ios_base&
#include <istream>
#include <cassert>
+#include "test_macros.h"
+
int f_called = 0;
template <class CharT>
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
struct testbuf
: public std::basic_streambuf<CharT>
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int bad=-1;
#include <istream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
struct testbuf
: public std::basic_streambuf<CharT>
#include <istream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
struct testbuf
: public std::basic_streambuf<CharT>
#include <istream>
#include <cassert>
+#include "test_macros.h"
+
int seekoff_called = 0;
template <class CharT>
#include <istream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
struct testbuf
: public std::basic_streambuf<CharT>
#include <istream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
struct testbuf
: public std::basic_streambuf<CharT>
#include <istream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
struct testbuf
#include <istream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
struct testbuf
: public std::basic_streambuf<CharT>
#include <istream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
struct testbuf
: public std::basic_streambuf<CharT>
#include <istream>
#include <cassert>
+#include "test_macros.h"
+
int sync_called = 0;
template <class CharT>
#include <istream>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::basic_ios<char>, std::basic_istream<char> >::value), "");
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
struct testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
struct testbuf
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
struct testbuf
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
struct testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
class testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
class testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
class testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
class testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
class testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
class testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
class testbuf
: public std::basic_streambuf<CharT>
#include <sstream>
#include <type_traits>
+#include "test_macros.h"
+
template <typename T>
static void test(std::ios_base::fmtflags fmt, const char *expected)
{
#include <cstdint>
#include <cassert>
+#include "test_macros.h"
+
template <typename T>
void test_octal(const char *expected)
{
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
class testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
class testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
class testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
class testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
class testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
class testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
class testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
class testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
class testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
class testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
class testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
class testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
class testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
class testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
class testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
class testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
class testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
class testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
class testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
class testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
int sync_called = 0;
template <class CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
class testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
int sync_called = 0;
template <class CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
class testbuf
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
int seekpos_called = 0;
template <class CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
int seekoff_called = 0;
template <class CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
int seekoff_called = 0;
template <class CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
int sync_called = 0;
template <class CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
class testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
class testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::basic_ios<char>, std::basic_ostream<char> >::value), "");
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
int sync_called = 0;
template <class CharT>
#include <string>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT, class Traits>
bool is_skipws ( const std::basic_istream<CharT, Traits>& is ) {
return ( is.flags() & std::ios_base::skipws ) != 0;
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
struct testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
struct testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
struct testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
struct testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
struct testbuf
: public std::basic_streambuf<CharT>
#include <ostream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
struct testbuf
: public std::basic_streambuf<CharT>
#include <iosfwd>
#include <cwchar> // for mbstate_t
+#include "test_macros.h"
+
template <class Ptr> void test()
{
Ptr p = 0;
#include <iostream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
#if 0
#include <iostream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
#if 0
#include <iostream>
+#include "test_macros.h"
+
int main(int, char**)
{
#if 0
#include <iostream>
+#include "test_macros.h"
+
int main(int, char**)
{
#if 0
#include <iostream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
#if 0
#include <iostream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
#if 0
#include <iostream>
+#include "test_macros.h"
+
int main(int, char**)
{
#if 0
#include <iostream>
+#include "test_macros.h"
+
int main(int, char**)
{
#if 0
#include <ios>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::fpos<int> f;
#include <ios>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::fpos<std::mbstate_t> P;
#include <ios>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::fpos<std::mbstate_t> P;
#include <ios>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::fpos<std::mbstate_t> P;
#include <ios>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::fpos<std::mbstate_t> P;
#include <ios>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::fpos<std::mbstate_t> P;
#include <ios>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::streamoff o(5);
#include <ios>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::fpos<std::mbstate_t> P;
#include <ios>
#include <cassert>
+#include "test_macros.h"
+
class test
: public std::ios
{
#include <ios>
#include <cassert>
+#include "test_macros.h"
+
class test
: public std::ios
{
#include <ios>
#include <cassert>
+#include "test_macros.h"
+
class test
: public std::ios
{
#include <ios>
#include <cassert>
+#include "test_macros.h"
+
class test
: public std::ios
{
#include <ios>
#include <cassert>
+#include "test_macros.h"
+
class test
: public std::ios
{
#include <ios>
#include <cassert>
+#include "test_macros.h"
+
class test
: public std::ios
{
#include <ios>
#include <cassert>
+#include "test_macros.h"
+
class test
: public std::ios
{
#include <ios>
#include <cassert>
+#include "test_macros.h"
+
class test
: public std::ios
{
#include <ios>
#include <cassert>
+#include "test_macros.h"
+
class test
: public std::ios
{
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
class test
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
class test
: public std::ios
{
#include <string>
#include <cassert>
+#include "test_macros.h"
+
class test
: public std::ios
{
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
class test
#include <string>
#include <cassert>
+#include "test_macros.h"
+
class test
: public std::ios
{
#include <cassert>
#include <cstdint>
+#include "test_macros.h"
+
class test
: public std::ios
{
#include <ios>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int index = std::ios_base::xalloc();
#include <ios>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
assert( std::ios_base::sync_with_stdio(false));
#include <system_error>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <system_error>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
// LWG2462 std::ios_base::failure is overspecified
#include <ios>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
assert(std::ios_base::boolalpha);
#include <ios>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
assert(std::ios_base::badbit);
#include <ios>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
assert(std::ios_base::app);
#include <ios>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
assert(std::ios_base::beg != std::ios_base::cur);
#include <ios>
+#include "test_macros.h"
+
int main(int, char**)
{
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <ios>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
const std::ios ios(0);
#include <ios>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::ios ios(0);
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
struct testbuf
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
struct testbuf
#include <ios>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
const std::wios ios(0);
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::ios ios(0);
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
struct testbuf
#include <ios>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
const std::basic_ios<char> ios(0);
#include <ios>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::ios ios(0);
#include <ios>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
const std::ios ios(0);
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
struct testbuf : public std::streambuf {};
int main(int, char**)
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
struct testbuf : public std::streambuf {};
int main(int, char**)
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
struct testbuf : public std::streambuf {};
int main(int, char**)
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
struct testbuf : public std::streambuf {};
int main(int, char**)
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
struct testbuf : public std::streambuf {};
int main(int, char**)
#include <ios>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::ios ios(0);
#include <ios>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::ios ios(0);
#include <ios>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::ios_base, std::basic_ios<char> >::value), "");
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
struct testbuf : public std::streambuf {};
int main(int, char**)
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
struct testbuf : public std::streambuf {};
int main(int, char**)
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
struct testbuf : public std::streambuf {};
int main(int, char**)
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
struct testbuf : public std::streambuf {};
int main(int, char**)
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
struct testbuf : public std::streambuf {};
int main(int, char**)
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
struct testbuf : public std::streambuf {};
int main(int, char**)
#include <cassert>
#include <string>
+#include "test_macros.h"
+
int main(int, char**)
{
const std::error_category& e_cat1 = std::iostream_category();
#include <ios>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <ios>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
struct testbuf : public std::streambuf {};
int main(int, char**)
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
struct testbuf : public std::streambuf {};
int main(int, char**)
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
struct testbuf : public std::streambuf {};
int main(int, char**)
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
struct testbuf : public std::streambuf {};
int main(int, char**)
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
struct testbuf : public std::streambuf {};
int main(int, char**)
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
struct testbuf : public std::streambuf {};
int main(int, char**)
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
struct testbuf : public std::streambuf {};
int main(int, char**)
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
struct testbuf : public std::streambuf {};
int main(int, char**)
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
struct testbuf : public std::streambuf {};
int main(int, char**)
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
struct testbuf : public std::streambuf {};
int main(int, char**)
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
struct testbuf : public std::streambuf {};
int main(int, char**)
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
struct testbuf : public std::streambuf {};
int main(int, char**)
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
struct testbuf : public std::streambuf {};
int main(int, char**)
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
struct testbuf : public std::streambuf {};
int main(int, char**)
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
struct testbuf : public std::streambuf {};
int main(int, char**)
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
struct testbuf : public std::streambuf {};
int main(int, char**)
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
struct testbuf : public std::streambuf {};
int main(int, char**)
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
struct testbuf : public std::streambuf {};
int main(int, char**)
#include <ios>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert(std::is_integral<std::streamoff>::value, "");
#include <ios>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert(std::is_integral<std::streamsize>::value, "");
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
template <class CharT>
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
template <class CharT>
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
struct test
: public std::basic_streambuf<CharT>
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
struct test
: public std::basic_streambuf<CharT>
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
struct test
: public std::basic_streambuf<CharT>
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
struct test
: public std::basic_streambuf<CharT>
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
template <class CharT>
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
int showmanyc_called = 0;
template <class CharT>
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
int uflow_called = 0;
struct test
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
int underflow_called = 0;
struct test
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
int xsgetn_called = 0;
struct test
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
int uflow_called = 0;
struct test
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
int pbackfail_called = 0;
struct test
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
int pbackfail_called = 0;
struct test
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
int overflow_called = 0;
struct test
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
int xsputn_called = 0;
struct test
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
template <class CharT>
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
template <class CharT>
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
struct test
: public std::basic_streambuf<CharT>
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
struct test
: public std::basic_streambuf<CharT>
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
struct test
: public std::basic_streambuf<CharT>
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
struct test
: public std::basic_streambuf<CharT>
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
int showmanyc_called = 0;
template <class CharT>
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
int underflow_called = 0;
struct test
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
struct test
: public std::basic_streambuf<char>
{
#include <cassert>
#include <cstring>
+#include "test_macros.h"
+
struct test
: public std::basic_streambuf<char>
{
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
int pbackfail_called = 0;
struct test
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
+
struct test
: public std::basic_streambuf<char>
{
#include <fstream>
#include <sstream>
#include <string>
+#include "test_macros.h"
#include "platform_support.h"
#include <cassert>
#include <cstring>
+#include "test_macros.h"
+
struct test
: public std::basic_streambuf<char>
{
#include <streambuf>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_same<std::streambuf::char_type, char>::value), "");
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::basic_istream<char>, std::basic_istringstream<char> >::value), "");
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::basic_ostream<char>, std::basic_ostringstream<char> >::value), "");
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
template<typename CharT>
struct testbuf
: std::basic_stringbuf<CharT>
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int overflow_called = 0;
template <class CharT>
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
struct testbuf
: public std::basic_stringbuf<CharT>
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
struct testbuf
: public std::basic_stringbuf<CharT>
#include <sstream>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::basic_streambuf<char>, std::basic_stringbuf<char> >::value), "");
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
std::vector<std::istringstream> vecis;
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
template<typename T>
struct NoDefaultAllocator : std::allocator<T>
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::basic_iostream<char>, std::basic_stringstream<char> >::value), "");
#include <iterator>
#include <type_traits>
+#include "test_macros.h"
+
struct A {};
template <class T>
#include <iterator>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <class It>
#include <iterator>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <class It>
#include <iterator>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <class It>
#include <iterator>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <class It>
#include <iterator>
#include <type_traits>
+#include "test_macros.h"
+
struct A {};
int main(int, char**)
#include <iterator>
#include <type_traits>
+#include "test_macros.h"
+
struct A {};
int main(int, char**)
#include <iterator>
+#include "test_macros.h"
+
struct not_an_iterator
{
};
#include <iterator>
#include <type_traits>
+#include "test_macros.h"
+
struct A {};
struct test_iterator
#include <iterator>
#include <type_traits>
+#include "test_macros.h"
+
struct A {};
int main(int, char**)
#include <iterator>
#include <type_traits>
+#include "test_macros.h"
+
struct A {};
int main(int, char**)
#include <iterator>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
std::bidirectional_iterator_tag tag;
#include <iterator>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
std::forward_iterator_tag tag;
#include <iterator>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
std::input_iterator_tag tag;
#include <iterator>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
std::output_iterator_tag tag;
#include <iterator>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
std::random_access_iterator_tag tag;
#include <vector>
#include "nasty_containers.hpp"
+#include "test_macros.h"
+
template <class C>
void
test(C c)
#include <cassert>
#include "nasty_containers.hpp"
+#include "test_macros.h"
+
template <class C>
void
test(C c)
#include <cassert>
#include "nasty_containers.hpp"
+#include "test_macros.h"
+
template <class C>
void
test(C c)
#include <vector>
#include <cassert>
+#include "test_macros.h"
+
template <class C>
void
test(C c)
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
template <class C>
void
test(C c)
#include <cassert>
#include "nasty_containers.hpp"
+#include "test_macros.h"
+
template <class C>
void
test(C c)
#include <cassert>
#include "nasty_containers.hpp"
+#include "test_macros.h"
+
template <class C>
void
test(C c)
#include <type_traits>
#include <vector>
+#include "test_macros.h"
+
template <class C>
struct find_container
: private std::back_insert_iterator<C>
#include <list>
#include "nasty_containers.hpp"
+#include "test_macros.h"
+
template <class C>
void
test(C c)
#include <cassert>
#include "nasty_containers.hpp"
+#include "test_macros.h"
+
template <class C>
void
test(C c)
#include <cassert>
#include "nasty_containers.hpp"
+#include "test_macros.h"
+
template <class C>
void
test(C c)
#include <cassert>
#include "nasty_containers.hpp"
+#include "test_macros.h"
+
template <class C>
void
test(C c)
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
template <class C>
void
test(C c)
#include <cassert>
#include "nasty_containers.hpp"
+#include "test_macros.h"
+
template <class C>
void
test(C c)
#include <cassert>
#include "nasty_containers.hpp"
+#include "test_macros.h"
+
template <class C>
void
test(C c)
#include <type_traits>
#include <vector>
+#include "test_macros.h"
+
template <class C>
struct find_container
: private std::front_insert_iterator<C>
#include <vector>
#include "nasty_containers.hpp"
+#include "test_macros.h"
+
template <class C>
void
test(C c)
#include <cassert>
#include "nasty_containers.hpp"
+#include "test_macros.h"
+
template <class C>
void
test(C c)
#include <cassert>
#include "nasty_containers.hpp"
+#include "test_macros.h"
+
template <class C>
void
test(C c)
#include <cassert>
#include "nasty_containers.hpp"
+#include "test_macros.h"
+
template <class C>
void
test(C c1, typename C::difference_type j,
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
template <class C>
void
test(C c1, typename C::difference_type j,
#include <cassert>
#include "nasty_containers.hpp"
+#include "test_macros.h"
+
template <class C>
void
test(C c)
#include <cassert>
#include "nasty_containers.hpp"
+#include "test_macros.h"
+
template <class C>
void
test(C c)
#include <iterator>
#include <type_traits>
+#include "test_macros.h"
#include "test_iterators.h"
template <class It>
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::istringstream inf(" 1 23");
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
double d_;
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::istringstream inf(" 1 23");
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::istringstream inf1(" 1 23");
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::istringstream inf(" 1 23");
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::istringstream inf(" 1 23");
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <iterator>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int ia[] = {1, 2, 3};
#include <vector>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int ia[] = {1, 2, 3};
#include <vector>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int ia[] = {1, 2, 3};
#include <iterator>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int ia[] = {1, 2, 3};
#include <vector>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int ia[] = {1, 2, 3};
#include <vector>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int ia[] = {1, 2, 3};
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::ostringstream outf;
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
struct MyTraits : std::char_traits<char> {};
typedef std::basic_ostringstream<char, MyTraits> StringStream;
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
struct MyTraits : std::char_traits<char> {};
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::ostringstream os;
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::ostringstream os;
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
template <typename Char, typename Traits = std::char_traits<Char> >
struct my_streambuf : public std::basic_streambuf<Char,Traits> {
typedef typename std::basic_streambuf<Char,Traits>::int_type int_type;
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
// typedef std::int8_t
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::exception, std::bad_alloc>::value),
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::bad_alloc, std::bad_array_new_length>::value),
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
void f() {}
int main(int, char**)
#include <new>
#include <cassert>
+#include "test_macros.h"
+
void f1() {}
void f2() {}
#include <new>
#include <cassert>
+#include "test_macros.h"
+
void f1() {}
void f2() {}
#include <new>
#include <cassert>
+#include "test_macros.h"
+
int A_constructed = 0;
struct A
#include <new>
#include <cassert>
+#include "test_macros.h"
+
int A_constructed = 0;
struct A
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::exception, std::bad_exception>::value),
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
class A
{
int data_;
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
void f1() {}
void f2() {}
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
void f1() {}
void f2() {}
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
void f() {}
int main(int, char**)
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
void f1()
{
std::exit(0);
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert(std::is_polymorphic<std::exception>::value,
#include <exception>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
static int constructed;
#include <exception>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::exception_ptr p;
#include <exception>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
static int constructed;
#include <exception>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
static int constructed;
#include <exception>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
~A()
#include <exception>
#include <cassert>
+#include "test_macros.h"
+
struct Uncaught {
Uncaught(int depth) : d_(depth) {}
~Uncaught() { assert(std::uncaught_exceptions() == d_); }
#include <initializer_list>
+#include "test_macros.h"
+
int main(int, char**)
{
#include <initializer_list>
#include <type_traits>
+#include "test_macros.h"
+
struct A {};
int main(int, char**)
#include <climits>
+#include "test_macros.h"
+
#ifndef CHAR_BIT
#error CHAR_BIT not defined
#endif
#include <limits>
+#include "test_macros.h"
+
typedef char one;
struct two {one _[2];};
#include <limits>
#include <complex>
+#include "test_macros.h"
+
template <class T>
void test()
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
A(int i = 0) : data_(i) {}
#include <limits>
+#include "test_macros.h"
+
typedef char one;
struct two {one _[2];};
#include <version>
+#include "test_macros.h"
+
int main(int, char**)
{
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::exception, std::bad_cast>::value),
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::exception, std::bad_typeid>::value),
#include <cstring>
#include <cassert>
+#include "test_macros.h"
+
bool test_constructor_explicit(std::type_info const&) { return false; }
bool test_constructor_explicit(std::string const&) { return true; }
#include <cstring>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
const std::type_info& t1 = typeid(int);
#include <csetjmp>
#include <type_traits>
+#include "test_macros.h"
+
#ifndef setjmp
#error setjmp not defined
#endif
#include <csignal>
#include <type_traits>
+#include "test_macros.h"
+
#ifndef SIG_DFL
#error SIG_DFL not defined
#endif
#include <cstdbool>
+#include "test_macros.h"
+
#ifndef __bool_true_false_are_defined
#error __bool_true_false_are_defined not defined
#endif
#include <cstdlib>
+#include "test_macros.h"
+
void f() {}
int main(int, char**)
#include <cstddef>
+#include "test_macros.h"
+
#ifndef NULL
#error NULL not defined
#endif
#include <cstddef>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::ptrdiff_t i = reinterpret_cast<std::ptrdiff_t>(nullptr);
#include <cstddef>
#include <type_traits>
+#include "test_macros.h"
+
// ptrdiff_t should:
// 1. be in namespace std.
#include <cstddef>
#include <type_traits>
+#include "test_macros.h"
+
// size_t should:
// 1. be in namespace std.
#include <clocale>
#include <type_traits>
+#include "test_macros.h"
+
#ifndef _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS
#ifndef LC_ALL
#include <stdio.h>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
int main(int, char**)
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
int main(int, char**)
#include <stdio.h>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
int main(int, char**)
#include <stdio.h>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
int main(int, char**)
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
template <class C>
class my_facet
: public std::collate<C>
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
void test(const T &) {}
#include "count_new.hpp"
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
class my_facet
: public std::ctype<char>
{
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <stdio.h>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <vector>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <stdio.h>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <stdio.h>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::ctype<char> F;
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <vector>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::ctype<char> F;
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h"
typedef std::codecvt_byname<char, char, std::mbstate_t> F;
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
typedef std::codecvt_byname<char16_t, char, std::mbstate_t> F;
class my_facet
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
typedef std::codecvt_byname<char32_t, char, std::mbstate_t> F;
class my_facet
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
typedef std::codecvt_byname<wchar_t, char, std::mbstate_t> F;
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
assert(std::codecvt_base::ok == 0);
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
typedef std::codecvt<char, char, std::mbstate_t> F;
class my_facet
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
//#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
typedef std::codecvt<char16_t, char, std::mbstate_t> F;
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
//#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
typedef std::codecvt<char32_t, char, std::mbstate_t> F;
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
typedef std::codecvt<wchar_t, char, std::mbstate_t> F;
class my_facet
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
typedef std::codecvt<char16_t, char, std::mbstate_t> F;
int main(int, char**)
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
typedef std::codecvt<char16_t, char, std::mbstate_t> F;
int main(int, char**)
#include <vector>
#include <cassert>
+#include "test_macros.h"
+
typedef std::codecvt<char16_t, char, std::mbstate_t> F;
int main(int, char**)
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
typedef std::codecvt<char16_t, char, std::mbstate_t> F;
int main(int, char**)
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
typedef std::codecvt<char16_t, char, std::mbstate_t> F;
int main(int, char**)
#include <stdio.h>
+#include "test_macros.h"
+
typedef std::codecvt<char16_t, char, std::mbstate_t> F;
int main(int, char**)
#include <vector>
#include <cassert>
+#include "test_macros.h"
+
typedef std::codecvt<char16_t, char, std::mbstate_t> F;
int main(int, char**)
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
typedef std::codecvt<char32_t, char, std::mbstate_t> F;
int main(int, char**)
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
typedef std::codecvt<char32_t, char, std::mbstate_t> F;
int main(int, char**)
#include <vector>
#include <cassert>
+#include "test_macros.h"
+
typedef std::codecvt<char32_t, char, std::mbstate_t> F;
int main(int, char**)
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
typedef std::codecvt<char32_t, char, std::mbstate_t> F;
int main(int, char**)
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
typedef std::codecvt<char32_t, char, std::mbstate_t> F;
int main(int, char**)
#include <stdio.h>
+#include "test_macros.h"
+
typedef std::codecvt<char32_t, char, std::mbstate_t> F;
int main(int, char**)
#include <vector>
#include <cassert>
+#include "test_macros.h"
+
typedef std::codecvt<char32_t, char, std::mbstate_t> F;
int main(int, char**)
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
typedef std::codecvt<char, char, std::mbstate_t> F;
int main(int, char**)
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
typedef std::codecvt<char, char, std::mbstate_t> F;
int main(int, char**)
#include <vector>
#include <cassert>
+#include "test_macros.h"
+
typedef std::codecvt<char, char, std::mbstate_t> F;
int main(int, char**)
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
typedef std::codecvt<char, char, std::mbstate_t> F;
int main(int, char**)
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
typedef std::codecvt<char, char, std::mbstate_t> F;
int main(int, char**)
#include <vector>
#include <cassert>
+#include "test_macros.h"
+
typedef std::codecvt<char, char, std::mbstate_t> F;
int main(int, char**)
#include <vector>
#include <cassert>
+#include "test_macros.h"
+
typedef std::codecvt<char, char, std::mbstate_t> F;
int main(int, char**)
#include <stdio.h>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::codecvt<char32_t, char, std::mbstate_t> F32_8;
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
typedef std::codecvt<wchar_t, char, std::mbstate_t> F;
int main(int, char**)
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
typedef std::codecvt<wchar_t, char, std::mbstate_t> F;
int main(int, char**)
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
typedef std::codecvt<wchar_t, char, std::mbstate_t> F;
int main(int, char**)
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
typedef std::codecvt<wchar_t, char, std::mbstate_t> F;
int main(int, char**)
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
typedef std::codecvt<wchar_t, char, std::mbstate_t> F;
int main(int, char**)
#include <cstddef>
#include <cstring>
+#include "test_macros.h"
+
typedef std::codecvt<wchar_t, char, std::mbstate_t> F;
int main(int, char**)
#include <vector>
#include <cassert>
+#include "test_macros.h"
+
typedef std::codecvt<wchar_t, char, std::mbstate_t> F;
int main(int, char**)
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::codecvt<char, char, std::mbstate_t> F;
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::codecvt<char16_t, char, std::mbstate_t> F;
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::codecvt<char32_t, char, std::mbstate_t> F;
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::codecvt<wchar_t, char, std::mbstate_t> F;
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
int main(int, char**)
#include <stdio.h>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
int main(int, char**)
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
int main(int, char**)
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
int main(int, char**)
#include <stdio.h>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
int main(int, char**)
#include <stdio.h>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
int main(int, char**)
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
int main(int, char**)
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
int main(int, char**)
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
int main(int, char**)
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
int main(int, char**)
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
int main(int, char**)
#include <cassert>
#include <limits.h>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
int main(int, char**)
#include <vector>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
int main(int, char**)
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
template <class C>
class my_facet
: public std::ctype<C>
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <stdio.h>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <vector>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <stdio.h>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <stdio.h>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <vector>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
typedef std::messages<char> F;
class my_facet
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
// As far as I can tell, the messages facet is untestable. I have a best
// effort implementation in the hopes that in the future I will learn how
// to test it.
#include <locale>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
std::messages_base mb;
#include <locale>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::locale::facet, std::messages<char> >::value), "");
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
typedef std::money_get<char, const char*> F;
class my_facet
#include <ios>
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "platform_support.h" // locale name macros
#include <ios>
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "platform_support.h" // locale name macros
#include <ios>
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "platform_support.h" // locale name macros
#include <ios>
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "platform_support.h" // locale name macros
#include <locale>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::locale::facet, std::money_get<char> >::value), "");
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
typedef std::money_put<char, char*> F;
class my_facet
#include <ios>
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "platform_support.h" // locale name macros
#include <ios>
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "platform_support.h" // locale name macros
#include <ios>
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "platform_support.h" // locale name macros
#include <ios>
#include <streambuf>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "platform_support.h" // locale name macros
#include <locale>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::locale::facet, std::money_put<char> >::value), "");
#include <limits>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
class Fnf
#include <limits>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
class Fnf
#include <limits>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
class Fnf
#include <limits>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
class Fnf
#include <limits>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
class Fnf
#include <limits>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
class Fnf
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
typedef std::moneypunct<char> F;
class my_facet
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
typedef std::moneypunct<char> F;
class Fnf
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
typedef std::moneypunct<char> F;
class Fnf
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
typedef std::moneypunct<char> F;
class Fnf
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
typedef std::moneypunct<char> F;
class Fnf
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
typedef std::moneypunct<char> F;
class Fnf
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
typedef std::moneypunct<char> F;
class Fnf
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
typedef std::moneypunct<char> F;
class Fnf
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
typedef std::moneypunct<char> F;
class Fnf
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
typedef std::moneypunct<char> F;
class Fnf
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::money_base mb; ((void)mb);
#include <locale>
#include <type_traits>
+#include "test_macros.h"
+
template <class T>
void test(const T &) {}
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
typedef std::num_put<char, char*> F;
class my_facet
#include <ios>
#include <cassert>
#include <streambuf>
+#include "test_macros.h"
#include "test_iterators.h"
typedef std::num_put<char, output_iterator<char*> > F;
#include <cassert>
#include <streambuf>
#include <cmath>
+#include "test_macros.h"
#include "test_iterators.h"
typedef std::num_put<char, output_iterator<char*> > F;
#include <ios>
#include <cassert>
#include <streambuf>
+#include "test_macros.h"
#include "test_iterators.h"
typedef std::num_put<char, output_iterator<char*> > F;
#include <cassert>
#include <streambuf>
#include <cmath>
+#include "test_macros.h"
#include "test_iterators.h"
typedef std::num_put<char, output_iterator<char*> > F;
#include <ios>
#include <cassert>
#include <streambuf>
+#include "test_macros.h"
#include "test_iterators.h"
typedef std::num_put<char, output_iterator<char*> > F;
#include <ios>
#include <cassert>
#include <streambuf>
+#include "test_macros.h"
#include "test_iterators.h"
typedef std::num_put<char, output_iterator<char*> > F;
#include <ios>
#include <cassert>
#include <streambuf>
+#include "test_macros.h"
#include "test_iterators.h"
typedef std::num_put<char, output_iterator<char*> > F;
#include <ios>
#include <cassert>
#include <streambuf>
+#include "test_macros.h"
#include "test_iterators.h"
typedef std::num_put<char, output_iterator<char*> > F;
#include <iterator>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::locale::facet, std::num_put<char> >::value), "");
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
typedef std::num_get<char, char*> F;
class my_facet
#include <ios>
#include <cassert>
#include <streambuf>
+#include "test_macros.h"
#include "test_iterators.h"
typedef std::num_get<char, input_iterator<const char*> > F;
#include <cassert>
#include <streambuf>
#include <cmath>
+#include "test_macros.h"
#include "test_iterators.h"
#include "hexfloat.h"
#include <cassert>
#include <streambuf>
#include <cmath>
+#include "test_macros.h"
#include "test_iterators.h"
#include "hexfloat.h"
#include <cassert>
#include <limits>
#include <streambuf>
+#include "test_macros.h"
#include "test_iterators.h"
typedef std::num_get<char, input_iterator<const char*> > F;
#include <cassert>
#include <streambuf>
#include <cmath>
+#include "test_macros.h"
#include "test_iterators.h"
#include "hexfloat.h"
#include <ios>
#include <cassert>
#include <streambuf>
+#include "test_macros.h"
#include "test_iterators.h"
typedef std::num_get<char, input_iterator<const char*> > F;
#include <ios>
#include <cassert>
#include <streambuf>
+#include "test_macros.h"
#include "test_iterators.h"
typedef std::num_get<char, input_iterator<const char*> > F;
#include <ios>
#include <cassert>
#include <streambuf>
+#include "test_macros.h"
#include "test_iterators.h"
typedef std::num_get<char, input_iterator<const char*> > F;
#include <ios>
#include <cassert>
#include <streambuf>
+#include "test_macros.h"
#include "test_iterators.h"
typedef std::num_get<char, input_iterator<const char*> > F;
#include <ios>
#include <cassert>
#include <streambuf>
+#include "test_macros.h"
#include "test_iterators.h"
typedef std::num_get<char, input_iterator<const char*> > F;
#include <ios>
#include <cassert>
#include <streambuf>
+#include "test_macros.h"
#include "test_iterators.h"
typedef std::num_get<char, input_iterator<const char*> > F;
#include <cassert>
#include <iostream>
+#include "test_macros.h"
+
using namespace std;
template <class T>
#include <iterator>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::locale::facet, std::num_get<char> >::value), "");
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "platform_support.h" // locale name macros
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "platform_support.h" // locale name macros
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "platform_support.h" // locale name macros
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "platform_support.h" // locale name macros
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "platform_support.h" // locale name macros
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "platform_support.h" // locale name macros
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "platform_support.h" // locale name macros
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "platform_support.h" // locale name macros
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "platform_support.h" // locale name macros
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "platform_support.h" // locale name macros
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "platform_support.h" // locale name macros
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "platform_support.h" // locale name macros
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "platform_support.h" // locale name macros
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "platform_support.h" // locale name macros
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
typedef std::time_get<char, const char*> F;
class my_facet
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
typedef std::time_get<char, input_iterator<const char*> > F;
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
typedef input_iterator<const char*> I;
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
typedef input_iterator<const wchar_t*> I;
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
typedef input_iterator<const char*> I;
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
typedef input_iterator<const char*> I;
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
typedef input_iterator<const wchar_t*> I;
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
typedef input_iterator<const char*> I;
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
typedef input_iterator<const char*> I;
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
typedef input_iterator<const wchar_t*> I;
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
typedef input_iterator<const char*> I;
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
typedef input_iterator<const wchar_t*> I;
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
typedef input_iterator<const char*> I;
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::time_base::dateorder d = std::time_base::no_order;
#include <iterator>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::locale::facet, std::time_get<char> >::value), "");
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "platform_support.h" // locale name macros
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
typedef std::time_put<char, char*> F;
class my_facet
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
typedef std::time_put<char, output_iterator<char*> > F;
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
typedef std::time_put<char, output_iterator<char*> > F;
#include <iterator>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::locale::facet, std::time_put<char> >::value), "");
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
int main(int, char**)
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
template <class C>
class my_facet
: public std::numpunct<C>
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l = std::locale::classic();
#include <codecvt>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
assert(std::consume_header == 4);
#include "count_new.hpp"
+#include "test_macros.h"
+
int main(int, char**)
{
assert(globalMemCounter.checkOutstandingNewEq(0));
#include <codecvt>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <codecvt>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <codecvt>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <codecvt>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <codecvt>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <codecvt>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT, size_t = sizeof(CharT)>
struct TestHelper;
template <class CharT>
#include <codecvt>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include "count_new.hpp"
+#include "test_macros.h"
+
int main(int, char**)
{
assert(globalMemCounter.checkOutstandingNewEq(0));
#include <codecvt>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <codecvt>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <codecvt>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <codecvt>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <codecvt>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <codecvt>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT, size_t = sizeof(CharT)>
struct TestHelper;
#include <codecvt>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <codecvt>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <codecvt>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <codecvt>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT, size_t = sizeof(CharT)>
struct TestHelper;
template <class CharT>
#include <codecvt>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <codecvt>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <codecvt>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT, size_t = sizeof(CharT)>
struct TestHelper;
template <class CharT>
#include <codecvt>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l;
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l;
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l;
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l;
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l;
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l;
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l;
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l;
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l;
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l;
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l;
#include <fstream>
#include <cassert>
+#include "test_macros.h"
+
struct test_buf
: public std::wbuffer_convert<std::codecvt_utf8<wchar_t> >
{
#include <fstream>
#include <cassert>
+#include "test_macros.h"
+
struct test_buf
: public std::wbuffer_convert<std::codecvt_utf8<wchar_t> >
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::wbuffer_convert<std::codecvt_utf8<wchar_t> > B;
#include <fstream>
#include <cassert>
+#include "test_macros.h"
+
class test_codecvt
: public std::codecvt<wchar_t, char, std::mbstate_t>
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::wbuffer_convert<std::codecvt_utf8<wchar_t> > B;
#include <codecvt>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <fstream>
#include <cassert>
+#include "test_macros.h"
+
struct test_buf
: public std::wbuffer_convert<std::codecvt_utf8<wchar_t> >
{
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l;
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::locale l;
#include <codecvt>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT, size_t = sizeof(CharT)>
struct TestHelper;
template <class CharT>
#include <codecvt>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <codecvt>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::codecvt_utf8<wchar_t> Codecvt;
#include <codecvt>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT, size_t = sizeof(CharT)>
struct TestHelper;
template <class CharT>
#include <locale>
#include <codecvt>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::codecvt_utf8<wchar_t> Codecvt;
#include <codecvt>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT, size_t = sizeof(CharT)>
struct TestHelper;
template <class CharT>
#include <locale>
#include <codecvt>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
struct my_facet
: public std::locale::facet
{
#include "count_new.hpp"
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
#include <new>
#include "count_new.hpp"
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
void check(const std::locale& loc)
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
#include "count_new.hpp"
#include <cassert>
#include "count_new.hpp"
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
void check(const std::locale& loc)
#include <cassert>
#include "count_new.hpp"
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
#include <cassert>
#include "count_new.hpp"
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
void check(const std::locale& loc)
#include <cassert>
#include "count_new.hpp"
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
#include <cassert>
#include "count_new.hpp"
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
void check(const std::locale& loc)
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
int main(int, char**)
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
int main(int, char**)
#include <locale>
#include <cassert>
+#include "test_macros.h"
+
void check(const std::locale& loc)
{
assert(std::has_facet<std::collate<char> >(loc));
#include <locale>
#include <cassert>
+#include "test_macros.h"
#include "platform_support.h" // locale name macros
void check(const std::locale& loc)
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
void test(const T &) {}
#include <ctgmath>
+#include "test_macros.h"
+
int main(int, char**)
{
std::complex<double> cd;
#include <tgmath.h>
+#include "test_macros.h"
+
int main(int, char**)
{
#include <cfenv>
#include <type_traits>
+#include "test_macros.h"
+
#ifndef FE_DIVBYZERO
#error FE_DIVBYZERO not defined
#endif
#include <ccomplex>
+#include "test_macros.h"
+
int main(int, char**)
{
std::complex<double> d;
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
#include "../cases.h"
template <class T>
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
#include "../cases.h"
template <class T>
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
#include "../cases.h"
template <class T>
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
#include "../cases.h"
template <class T>
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
#include "../cases.h"
template <class T>
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
using namespace std::literals;
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
using namespace std;
#include <complex>
#include <cassert>
+#include "test_macros.h"
+
template <class T, class X>
void
test()
#include <complex>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
void
test()
#include <complex>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
void
test()
#include <complex>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
void
test()
#include <complex>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
void
test()
#include <complex>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
void
test()
#include <complex>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
void
test()
#include <complex>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
void
test()
#include <complex>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
void
test()
#include <complex>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
void
test()
#include <complex>
#include <cassert>
+#include "test_macros.h"
#include "../cases.h"
template <class T>
#include <complex>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
void
test(const std::complex<T>& lhs, const T& rhs, std::complex<T> x)
#include <complex>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
void
test(const std::complex<T>& lhs, const std::complex<T>& rhs, std::complex<T> x)
#include <complex>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
void
test(const std::complex<T>& lhs, const T& rhs, std::complex<T> x)
#include <complex>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
void
test(const std::complex<T>& lhs, const std::complex<T>& rhs, std::complex<T> x)
#include <complex>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
void
test(const std::complex<T>& lhs, const T& rhs, std::complex<T> x)
#include <complex>
#include <cassert>
+#include "test_macros.h"
#include "../cases.h"
template <class T>
#include <complex>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
void
test(const std::complex<T>& lhs, const T& rhs, std::complex<T> x)
#include <complex>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
void
test(const T& lhs, const std::complex<T>& rhs, std::complex<T> x)
#include <complex>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
void
test(const T& lhs, const std::complex<T>& rhs, std::complex<T> x)
#include <complex>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
void
test(const T& lhs, const std::complex<T>& rhs, std::complex<T> x)
#include <complex>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
void
test(const T& lhs, const std::complex<T>& rhs, std::complex<T> x)
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::complex<double> c(1, 2);
#include <complex>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
void
test()
#include <complex>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
void
test()
#include <complex>
#include <cassert>
+#include "test_macros.h"
#include "../cases.h"
template <class T>
#include <complex>
#include <cassert>
+#include "test_macros.h"
#include "../cases.h"
template <class T>
#include <complex>
#include <cassert>
+#include "test_macros.h"
#include "../cases.h"
template <class T>
#include <complex>
#include <cassert>
+#include "test_macros.h"
#include "../cases.h"
template <class T>
#include <complex>
#include <cassert>
+#include "test_macros.h"
#include "../cases.h"
template <class T>
#include <complex>
#include <cassert>
+#include "test_macros.h"
#include "../cases.h"
template <class T>
#include <complex>
#include <cassert>
+#include "test_macros.h"
#include "../cases.h"
template <class T>
#include <complex>
#include <cassert>
+#include "test_macros.h"
#include "../cases.h"
template <class T>
#include <complex>
#include <cassert>
+#include "test_macros.h"
#include "../cases.h"
template <class T>
#include <complex>
#include <cassert>
+#include "test_macros.h"
#include "../cases.h"
template <class T>
#include <complex>
#include <cassert>
+#include "test_macros.h"
#include "../cases.h"
template <class T>
#include <complex>
#include <cassert>
+#include "test_macros.h"
#include "../cases.h"
template <class T>
#include <complex>
#include <cassert>
+#include "test_macros.h"
#include "../cases.h"
template <class T>
#include <complex>
#include <cassert>
+#include "test_macros.h"
#include "../cases.h"
template <class T>
#include <complex>
#include <cassert>
+#include "test_macros.h"
#include "../cases.h"
template <class T>
#include <complex>
#include <cassert>
+#include "test_macros.h"
#include "../cases.h"
template <class T>
#include <complex>
#include <cassert>
+#include "test_macros.h"
#include "../cases.h"
template <class T>
#include <complex>
#include <cassert>
+#include "test_macros.h"
#include "../cases.h"
template <class T>
#include <complex>
#include <cassert>
+#include "test_macros.h"
#include "../cases.h"
template <class T>
#include <complex>
#include <cassert>
+#include "test_macros.h"
#include "../cases.h"
template <class T>
#include <complex>
#include <cassert>
+#include "test_macros.h"
#include "../cases.h"
template <class T>
#include <complex>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
void
test(const std::complex<T>& z, std::complex<T> x)
#include <complex>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
void
test()
#include <complex>
#include <cassert>
+#include "test_macros.h"
#include "../cases.h"
template <class T>
#include <complex>
#include <cassert>
+#include "test_macros.h"
#include "../cases.h"
template <class T>
#include <complex>
#include <cassert>
+#include "test_macros.h"
#include "../cases.h"
template <class T>
#include <complex>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
void
test()
#include <complex>
#include <type_traits>
+#include "test_macros.h"
+
template <class T>
void
test()
#include <complex>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
void
test()
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::gslice gs;
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::size_t a1[] = {1, 2, 3};
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::slice s;
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::slice s(1, 3, 2);
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
#include <valarray>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_same<std::gslice_array<int>::value_type, int>::value), "");
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
#include <valarray>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_same<std::indirect_array<int>::value_type, int>::value), "");
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
#include <valarray>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_same<std::mask_array<int>::value_type, int>::value), "");
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
#include <valarray>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_same<std::slice_array<int>::value_type, int>::value), "");
#include <valarray>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_same<std::valarray<int>::value_type, int>::value), "");
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
struct S
{
S() : x_(0) { default_ctor_called = true; }
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
struct S
{
S() : x_(0) { default_ctor_called = true; }
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
struct S {
S() { ctor_called = true; }
static bool ctor_called;
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
struct S {
S() : x(1) {}
~S() { ++cnt_dtor; }
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
typedef int T;
T f(const T& t) {return t + 5;}
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
typedef int T;
T f(T t) {return t + 5;}
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cstddef>
+#include "test_macros.h"
+
bool is_about(double x, double y, int p)
{
std::ostringstream o;
#include <sstream>
#include <cstddef>
+#include "test_macros.h"
+
bool is_about(double x, double y, int p)
{
std::ostringstream o;
#include <sstream>
#include <cstddef>
+#include "test_macros.h"
+
bool is_about(double x, double y, int p)
{
std::ostringstream o;
#include <sstream>
#include <cstddef>
+#include "test_macros.h"
+
bool is_about(double x, double y, int p)
{
std::ostringstream o;
#include <sstream>
#include <cstddef>
+#include "test_macros.h"
+
bool is_about(double x, double y, int p)
{
std::ostringstream o;
#include <sstream>
#include <cstddef>
+#include "test_macros.h"
+
bool is_about(double x, double y, int p)
{
std::ostringstream o;
#include <sstream>
#include <cstddef>
+#include "test_macros.h"
+
bool is_about(double x, double y, int p)
{
std::ostringstream o;
#include <sstream>
#include <cstddef>
+#include "test_macros.h"
+
bool is_about(double x, double y, int p)
{
std::ostringstream o;
#include <sstream>
#include <cstddef>
+#include "test_macros.h"
+
bool is_about(double x, double y, int p)
{
std::ostringstream o;
#include <sstream>
#include <cstddef>
+#include "test_macros.h"
+
bool is_about(double x, double y, int p)
{
std::ostringstream o;
#include <sstream>
#include <cstddef>
+#include "test_macros.h"
+
bool is_about(double x, double y, int p)
{
std::ostringstream o;
#include <sstream>
#include <cstddef>
+#include "test_macros.h"
+
bool is_about(double x, double y, int p)
{
std::ostringstream o;
#include <sstream>
#include <cstddef>
+#include "test_macros.h"
+
bool is_about(double x, double y, int p)
{
std::ostringstream o;
#include <sstream>
#include <cstddef>
+#include "test_macros.h"
+
bool is_about(double x, double y, int p)
{
std::ostringstream o;
#include <sstream>
#include <cstddef>
+#include "test_macros.h"
+
bool is_about(double x, double y, int p)
{
std::ostringstream o;
#include <sstream>
#include <cstddef>
+#include "test_macros.h"
+
bool is_about(double x, double y, int p)
{
std::ostringstream o;
#include <sstream>
#include <cstddef>
+#include "test_macros.h"
+
bool is_about(double x, double y, int p)
{
std::ostringstream o;
#include <sstream>
#include <cstddef>
+#include "test_macros.h"
+
bool is_about(double x, double y, int p)
{
std::ostringstream o;
#include <sstream>
#include <cstddef>
+#include "test_macros.h"
+
bool is_about(double x, double y, int p)
{
std::ostringstream o;
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <valarray>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <numeric>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <class Iter, class T>
#include <functional>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <class Iter, class T>
#include <iterator>
#include <vector>
+#include "test_macros.h"
#include "test_iterators.h"
template <class Iter1, class T, class Iter2>
#include <iterator>
#include <vector>
+#include "test_macros.h"
#include "test_iterators.h"
template <class Iter1, class T, class Op, class Iter2>
#include <iterator>
#include <vector>
+#include "test_macros.h"
#include "test_iterators.h"
template <class Iter1, class Iter2>
#include <iterator>
#include <vector>
+#include "test_macros.h"
#include "test_iterators.h"
template <class Iter1, class T, class Op, class Iter2>
#include <iterator>
#include <vector>
+#include "test_macros.h"
#include "test_iterators.h"
template <class Iter1, class T, class Op, class Iter2>
#include <numeric>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <class Iter1, class Iter2, class T>
#include <functional>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <class Iter1, class Iter2, class T>
#include <numeric>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <class InIter>
#include <cstdlib> // for rand()
#include <type_traits>
+#include "test_macros.h"
+
constexpr struct {
int x;
int y;
#include <numeric>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <class InIter, class OutIter>
#include <functional>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <class InIter, class OutIter>
#include <numeric>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <class Iter, class T>
#include <numeric>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <class Iter, class T>
#include <numeric>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <class Iter, class T, class Op>
#include <iterator>
#include <vector>
+#include "test_macros.h"
#include "test_iterators.h"
struct add_one {
#include <iterator>
#include <vector>
+#include "test_macros.h"
#include "test_iterators.h"
struct add_one {
#include <iterator>
#include <vector>
+#include "test_macros.h"
#include "test_iterators.h"
struct add_one {
#include <utility>
#include <iterator>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "test_iterators.h"
#include <cassert>
#include <iterator>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "test_iterators.h"
#include <cassert>
#include <iterator>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "test_iterators.h"
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::random_device r;
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
template <class T>
inline
T
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
template <class T>
inline
T
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <vector>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
inline
T
#include <vector>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
inline
T
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <vector>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
inline
T
#include <vector>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
inline
T
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <vector>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
inline
T
#include <vector>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
inline
T
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <vector>
#include <algorithm>
+#include "test_macros.h"
+
double
f(double x, double a, double b)
{
#include <vector>
#include <algorithm>
+#include "test_macros.h"
+
double
f(double x, double a, double b)
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <numeric>
#include <cstddef>
+#include "test_macros.h"
+
template <class T>
inline
T
#include <numeric>
#include <cstddef>
+#include "test_macros.h"
+
template <class T>
inline
T
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <algorithm>
#include <cmath>
+#include "test_macros.h"
+
double fac(double x)
{
double r = 1;
#include <algorithm>
#include <cmath>
+#include "test_macros.h"
+
double fac(double x)
{
double r = 1;
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <vector>
#include <numeric>
+#include "test_macros.h"
+
template <class T>
inline
T
#include <vector>
#include <numeric>
+#include "test_macros.h"
+
template <class T>
inline
T
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <numeric>
#include <cstddef>
+#include "test_macros.h"
+
template <class T>
inline
T
#include <numeric>
#include <cstddef>
+#include "test_macros.h"
+
template <class T>
inline
T
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <vector>
#include <numeric>
+#include "test_macros.h"
+
template <class T>
inline
T
#include <vector>
#include <numeric>
+#include "test_macros.h"
+
template <class T>
inline
T
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <numeric>
#include <cstddef>
+#include "test_macros.h"
+
template <class T>
inline
T
#include <numeric>
#include <cstddef>
+#include "test_macros.h"
+
template <class T>
inline
T
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <vector>
#include <numeric>
+#include "test_macros.h"
+
template <class T>
inline
T
#include <vector>
#include <numeric>
+#include "test_macros.h"
+
template <class T>
inline
T
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <vector>
#include <numeric>
+#include "test_macros.h"
+
template <class T>
inline
T
#include <vector>
#include <numeric>
+#include "test_macros.h"
+
template <class T>
inline
T
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <vector>
#include <numeric>
+#include "test_macros.h"
+
template <class T>
inline
T
#include <vector>
#include <numeric>
+#include "test_macros.h"
+
template <class T>
inline
T
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <numeric>
#include <cstddef>
+#include "test_macros.h"
+
template <class T>
inline
T
#include <numeric>
#include <cstddef>
+#include "test_macros.h"
+
template <class T>
inline
T
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
double fw(double x)
{
return x+1;
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <vector>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <vector>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
double fw(double x)
{
return x+1;
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
double fw(double x)
{
return 2*x;
#include <random>
#include <cassert>
+#include "test_macros.h"
+
double f(double x)
{
return x*2;
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <algorithm> // for sort
#include <cassert>
+#include "test_macros.h"
+
template <class T>
inline
T
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
+
template <class T>
inline
T
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
double fw(double x)
{
return 2*x;
#include <random>
#include <cassert>
+#include "test_macros.h"
+
double f(double x)
{
return x*2;
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
double fw(double x)
{
return 2*x;
#include <random>
#include <cassert>
+#include "test_macros.h"
+
double f(double x)
{
return x*2;
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include <limits>
+#include "test_macros.h"
+
template <class T>
inline
T
#include <cassert>
#include <limits>
+#include "test_macros.h"
+
template <class T>
inline
T
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
double fw(double x)
{
return 2*x;
#include <random>
#include <cassert>
+#include "test_macros.h"
+
double f(double x)
{
return x*2;
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <numeric>
#include <cstddef>
+#include "test_macros.h"
+
template <class T>
inline
T
#include <numeric>
#include <cstddef>
+#include "test_macros.h"
+
template <class T>
inline
T
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <numeric>
#include <cstddef>
+#include "test_macros.h"
+
template <class T>
inline
T
#include <numeric>
#include <cstddef>
+#include "test_macros.h"
+
template <class T>
inline
T
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <limits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
template <class T, T a, T c, T m>
void
test1()
#include <random>
#include <cassert>
+#include "test_macros.h"
+
template <class T, T a, T c, T m>
void
test1()
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
void
test1()
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
template <class T, T a, T c, T m>
void
test1()
#include <random>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
void
rand0()
#include <random>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
void
randu()
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
template <class T>
void
test()
#include <random>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
void
test1()
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <cstddef>
#if TEST_STD_VER >= 11
#include <initializer_list>
+
+#include "test_macros.h"
#endif
struct all_zero_seed_seq {
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
void
test1()
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::knuth_b e;
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::minstd_rand e;
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::minstd_rand0 e;
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::mt19937 e;
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::mt19937_64 e;
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::ranlux24 e;
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::ranlux24_base e;
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::ranlux48 e;
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::ranlux48_base e;
#include <random>
#include <cassert>
+#include "test_macros.h"
#include "truncate_fp.h"
int main(int, char**)
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::seed_seq s;
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::seed_seq s= {5, 4, 3, 2, 1};
#include <random>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
unsigned a[5] = {5, 4, 3, 2, 1};
#include <random>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_same<std::seed_seq::result_type, std::uint_least32_t>::value), "");
#include <cassert>
#include <regex>
+#include "test_macros.h"
+
int main(int, char**) {
assert(std::regex_match("X", std::regex("[X]")));
#include <regex>
#include <cassert>
+#include "test_macros.h"
+
// PR34310
int main(int, char**)
#include <regex>
#include <cassert>
+#include "test_macros.h"
+
template <class CharT>
void
test(const CharT* p, std::size_t len, unsigned mc)
#include "poisoned_hash_helper.hpp"
+#include "test_macros.h"
+
int main(int, char**) {
test_library_hash_specializations_available();
{
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
using namespace std::literals;
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
using namespace std::literals::string_literals;
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
using namespace std;
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <cassert>
#include <stdexcept>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <exception>
#include <cstdlib>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{ // N3644 testing
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <cassert>
#include <cstddef>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "min_allocator.h"
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
#include "min_allocator.h"
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <iterator>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
#include "test_iterators.h"
#include <algorithm>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <sstream>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <sstream>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <sstream>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S, class SV>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S, class SV>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S, class SV>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S, class SV>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S, class SV>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S, class SV>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S, class SV>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S, class SV>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S, class SV>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S, class SV>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S, class SV>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S, class SV>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int sign(int x)
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int sign(int x)
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S, class SV>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S, class SV>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S, class SV>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S, class SV>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S, class SV>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
template <class S, class SV>
#include <string>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <iterator>
#include <type_traits>
+#include "test_macros.h"
#include "test_traits.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
char s2[3] = {0};
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
char s1[] = {1, 2, 3};
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
assert(std::char_traits<char>::eof() == EOF);
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
assert(std::char_traits<char>::eq('a', 'a'));
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
assert( std::char_traits<char>::eq_int_type('a', 'a'));
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
assert( std::char_traits<char>::lt('\0', 'A'));
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
char s1[] = {1, 2, 3};
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
assert(std::char_traits<char>::not_eof('a') == 'a');
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
assert(std::char_traits<char>::to_char_type('a') == 'a');
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
assert(std::char_traits<char>::to_int_type('a') == 'a');
#include <string>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_same<std::char_traits<char>::char_type, char>::value), "");
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
#include <type_traits>
#include <cstdint>
+#include "test_macros.h"
+
int main(int, char**)
{
#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
#include <type_traits>
#include <cstdint>
+#include "test_macros.h"
+
int main(int, char**)
{
#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
#include <type_traits>
#include <cstdint>
+#include "test_macros.h"
+
int main(int, char**)
{
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
wchar_t s2[3] = {0};
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
wchar_t s1[] = {1, 2, 3};
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
assert(std::char_traits<wchar_t>::eof() == WEOF);
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
assert(std::char_traits<wchar_t>::eq(L'a', L'a'));
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
assert( std::char_traits<wchar_t>::eq_int_type(L'a', L'a'));
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
assert(!std::char_traits<wchar_t>::lt(L'a', L'a'));
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
wchar_t s1[] = {1, 2, 3};
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
assert(std::char_traits<wchar_t>::not_eof(L'a') == L'a');
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
assert(std::char_traits<wchar_t>::to_char_type(L'a') == L'a');
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
assert(std::char_traits<wchar_t>::to_int_type(L'a') == L'a');
#include <string>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_same<std::char_traits<wchar_t>::char_type, wchar_t>::value), "");
#include <cassert>
#include <sstream>
+#include "test_macros.h"
+
template <class T>
void
test_signed()
#include <cassert>
#include <sstream>
+#include "test_macros.h"
+
template <class T>
void
test_signed()
#include <string>
#include <cassert>
+#include "test_macros.h"
+
template <class S>
void
test(const std::string &lhs, S rhs, bool x)
#include <string_view>
#include <cassert>
+#include "test_macros.h"
+
template <class S>
void
test(const S& lhs, const typename S::value_type* rhs, bool x, bool y)
#include <string_view>
#include <cassert>
+#include "test_macros.h"
+
template <class S>
void
test(const S& lhs, const typename S::value_type* rhs, bool x, bool y)
#include <string_view>
#include <cassert>
+#include "test_macros.h"
+
template <class S>
void
test(const S& lhs, const typename S::value_type* rhs, bool x, bool y)
#include <string_view>
#include <cassert>
+#include "test_macros.h"
+
template <class S>
void
test(const S& lhs, const typename S::value_type* rhs, bool x, bool y)
#include <string>
#include <cassert>
+#include "test_macros.h"
+
template <class S>
void
test(const std::string &lhs, S rhs, bool x)
#include <string_view>
#include <cassert>
+#include "test_macros.h"
+
template <class S>
void
test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
#include <string_view>
#include <cassert>
+#include "test_macros.h"
+
template <class S>
void
test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
#include <string_view>
#include <cassert>
+#include "test_macros.h"
+
template <class S>
void
test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
#include <string_view>
#include <cassert>
+#include "test_macros.h"
+
template <class S>
void
test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
#include "poisoned_hash_helper.hpp"
+#include "test_macros.h"
+
int main(int, char**) {
test_library_hash_specializations_available();
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
using std::string_view;
using std::wstring_view;
#include <string_view>
+#include "test_macros.h"
+
int main(int, char**) {
return 0;
}
#include <string_view>
+#include "test_macros.h"
+
int main(int, char**) {
return 0;
}
#include <string_view>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
using namespace std::literals;
#include <string_view>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
using namespace std::literals::string_view_literals;
#include <string_view>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
using namespace std;
#include <numeric>
#include <vector>
+#include "test_macros.h"
+
static int worker(std::vector<int> const& data) {
return std::accumulate(data.begin(), data.end(), 0);
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
int f_async() {
typedef std::chrono::milliseconds ms;
std::this_thread::sleep_for(ms(200));
#include <future>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
const std::error_category& e_cat = std::future_category();
#include <future>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
const std::error_category& e_cat = std::future_category();
#include <future>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
const std::error_category& e_cat = std::future_category();
#include <cstring>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
const std::error_category& ec = std::future_category();
#include <future>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <future>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <future>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_convertible<std::future_error*,
#include <future>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert(std::future_errc::broken_promise != std::future_errc::future_already_retrieved, "");
#include <future>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert(static_cast<int>(std::future_status::ready) == 0, "");
#include <future>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <future>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <future>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <future>
#include <cassert>
+#include "test_macros.h"
+
void func(std::promise<int> p)
{
p.set_exception_at_thread_exit(std::make_exception_ptr(3));
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
int i = 0;
void func(std::promise<int&> p)
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
A() {}
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
void func(std::promise<std::unique_ptr<int>> p)
{
p.set_value_at_thread_exit(std::unique_ptr<int>(new int(5)));
#include <future>
#include <cassert>
+#include "test_macros.h"
+
void func(std::promise<int> p)
{
const int i = 5;
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
int i = 0;
void func(std::promise<void> p)
#include <future>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <future>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
int main(int, char**)
// : true_type { };
#include <future>
+#include "test_macros.h"
#include "test_allocator.h"
int main(int, char**)
#include <future>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <future>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <future>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
int main(int, char**)
#include <future>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <future>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <future>
#include <cassert>
+#include "test_macros.h"
+
void func1(std::promise<int> p)
{
std::this_thread::sleep_for(std::chrono::milliseconds(500));
#include <future>
#include <cassert>
+#include "test_macros.h"
+
typedef std::chrono::milliseconds ms;
void func1(std::promise<int> p)
#include <atomic>
#include <cassert>
+#include "test_macros.h"
+
enum class WorkerThreadState { Uninitialized, AllowedToRun, Exiting };
typedef std::chrono::milliseconds ms;
#include <future>
#include <cassert>
+#include "test_macros.h"
+
class A
{
long data_;
#include <future>
#include <cassert>
+#include "test_macros.h"
+
struct A {};
int main(int, char**)
#include <future>
#include <cassert>
+#include "test_macros.h"
+
class A
{
long data_;
#include <future>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <future>
#include <cassert>
+#include "test_macros.h"
+
class A
{
long data_;
#include <future>
#include <cassert>
+#include "test_macros.h"
+
class A
{
long data_;
#include <future>
#include <cassert>
+#include "test_macros.h"
+
class A
{
long data_;
// : true_type { };
#include <future>
+#include "test_macros.h"
#include "test_allocator.h"
int main(int, char**)
#include <future>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <future>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
int main(int, char**)
#include <future>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <future>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <future>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <future>
#include <cassert>
+#include "test_macros.h"
+
void func1(std::promise<int> p)
{
std::this_thread::sleep_for(std::chrono::milliseconds(500));
#include <future>
#include <cassert>
+#include "test_macros.h"
+
typedef std::chrono::milliseconds ms;
void func1(std::promise<int> p)
#include <atomic>
#include <cassert>
+#include "test_macros.h"
+
enum class WorkerThreadState { Uninitialized, AllowedToRun, Exiting };
typedef std::chrono::milliseconds ms;
#include <thread>
+#include "test_macros.h"
+
int main(int, char**)
{
#ifndef __STDCPP_THREADS__
#include <condition_variable>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
assert(static_cast<int>(std::cv_status::no_timeout) == 0);
#include <chrono>
#include <cassert>
+#include "test_macros.h"
+
std::condition_variable cv;
std::mutex mut;
#include <condition_variable>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::condition_variable cv;
#include <thread>
#include <cassert>
+#include "test_macros.h"
+
std::condition_variable* cv;
std::mutex m;
typedef std::unique_lock<std::mutex> Lock;
#include <thread>
#include <cassert>
+#include "test_macros.h"
+
std::condition_variable cv;
std::mutex mut;
#include <thread>
#include <cassert>
+#include "test_macros.h"
+
std::condition_variable cv;
std::mutex mut;
#include <thread>
#include <cassert>
+#include "test_macros.h"
+
std::condition_variable cv;
std::mutex mut;
#include <chrono>
#include <cassert>
+#include "test_macros.h"
+
std::condition_variable cv;
std::mutex mut;
#include <chrono>
#include <cassert>
+#include "test_macros.h"
+
class Pred
{
int& i_;
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
std::condition_variable cv;
std::mutex mut;
#include <chrono>
#include <cassert>
+#include "test_macros.h"
+
struct Clock
{
typedef std::chrono::milliseconds duration;
#include <chrono>
#include <cassert>
+#include "test_macros.h"
+
struct Clock
{
typedef std::chrono::milliseconds duration;
#include <condition_variable>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::condition_variable_any cv;
#include <thread>
#include <cassert>
+#include "test_macros.h"
+
std::condition_variable_any* cv;
std::mutex m;
#include <thread>
#include <cassert>
+#include "test_macros.h"
+
std::condition_variable_any cv;
typedef std::timed_mutex L0;
#include <thread>
#include <cassert>
+#include "test_macros.h"
+
std::condition_variable_any cv;
typedef std::timed_mutex L0;
#include <thread>
#include <cassert>
+#include "test_macros.h"
+
std::condition_variable_any cv;
typedef std::timed_mutex L0;
#include <chrono>
#include <cassert>
+#include "test_macros.h"
+
std::condition_variable_any cv;
typedef std::timed_mutex L0;
#include <chrono>
#include <cassert>
+#include "test_macros.h"
+
class Pred
{
int& i_;
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
std::condition_variable_any cv;
typedef std::timed_mutex L0;
#include <chrono>
#include <cassert>
+#include "test_macros.h"
+
struct Clock
{
typedef std::chrono::milliseconds duration;
#include <chrono>
#include <cassert>
+#include "test_macros.h"
+
struct Clock
{
typedef std::chrono::milliseconds duration;
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
std::mutex m;
typedef std::chrono::system_clock Clock;
#include <mutex>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_same<std::lock_guard<std::mutex>::mutex_type,
#include <shared_mutex>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::shared_lock<std::shared_timed_mutex> ul;
#include <cassert>
#include "nasty_containers.hpp"
+#include "test_macros.h"
+
int main(int, char**)
{
#include <cassert>
#include "nasty_containers.hpp"
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include "nasty_containers.hpp"
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include "nasty_containers.hpp"
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
std::shared_timed_mutex m;
typedef std::chrono::system_clock Clock;
#include <shared_mutex>
#include <cassert>
+#include "test_macros.h"
+
struct mutex
{
void lock_shared() {}
#include <shared_mutex>
#include <cassert>
+#include "test_macros.h"
+
struct mutex
{
void lock_shared() {}
#include <shared_mutex>
#include <cassert>
+#include "test_macros.h"
+
struct mutex
{
static int lock_count;
#include <shared_mutex>
#include <cassert>
+#include "test_macros.h"
+
std::shared_timed_mutex m;
int main(int, char**)
#include <shared_mutex>
#include <cassert>
+#include "test_macros.h"
+
std::shared_timed_mutex m;
int main(int, char**)
#include <shared_mutex>
#include <cassert>
+#include "test_macros.h"
+
std::shared_timed_mutex m;
int main(int, char**)
#include <shared_mutex>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_same<std::shared_lock<std::mutex>::mutex_type,
#include <mutex>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::unique_lock<std::mutex> ul;
#include <cassert>
#include "nasty_containers.hpp"
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include "nasty_containers.hpp"
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include "nasty_containers.hpp"
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
#include "nasty_containers.hpp"
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
std::timed_mutex m;
typedef std::chrono::steady_clock Clock;
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
std::timed_mutex m;
typedef std::chrono::steady_clock Clock;
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
std::mutex m;
typedef std::chrono::system_clock Clock;
#include <mutex>
#include <cassert>
+#include "test_macros.h"
+
struct mutex
{
void lock() {}
#include <mutex>
#include <cassert>
+#include "test_macros.h"
+
struct mutex
{
void lock() {}
#include <mutex>
#include <cassert>
+#include "test_macros.h"
+
struct mutex
{
static int lock_count;
#include <mutex>
#include <cassert>
+#include "test_macros.h"
+
std::mutex m;
int main(int, char**)
#include <mutex>
#include <cassert>
+#include "test_macros.h"
+
std::mutex m;
int main(int, char**)
#include <mutex>
#include <cassert>
+#include "test_macros.h"
+
std::mutex m;
int main(int, char**)
#include <mutex>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_same<std::unique_lock<std::mutex>::mutex_type,
#include <mutex>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::defer_lock_t T1;
#include <mutex>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert(std::is_nothrow_default_constructible<std::mutex>::value, "");
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
std::mutex m;
typedef std::chrono::system_clock Clock;
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
std::mutex m;
typedef std::chrono::system_clock Clock;
#include <mutex>
+#include "test_macros.h"
+
int main(int, char**)
{
std::recursive_mutex m;
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
std::recursive_mutex m;
typedef std::chrono::system_clock Clock;
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
std::recursive_mutex m;
typedef std::chrono::system_clock Clock;
#include <shared_mutex>
+#include "test_macros.h"
+
int main(int, char**)
{
std::shared_mutex m;
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
std::shared_mutex m;
typedef std::chrono::system_clock Clock;
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
std::shared_mutex m;
typedef std::chrono::system_clock Clock;
#include <shared_mutex>
+#include "test_macros.h"
+
int main(int, char**)
{
std::shared_timed_mutex m;
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
std::shared_timed_mutex m;
typedef std::chrono::system_clock Clock;
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
std::shared_timed_mutex m;
const int total_readers = 2;
#include <mutex>
+#include "test_macros.h"
+
int main(int, char**)
{
std::timed_mutex m;
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
std::timed_mutex m;
typedef std::chrono::system_clock Clock;
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
std::timed_mutex m;
typedef std::chrono::system_clock Clock;
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
std::timed_mutex m;
typedef std::chrono::steady_clock Clock;
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
std::timed_mutex m;
typedef std::chrono::steady_clock Clock;
#include <mutex>
+#include "test_macros.h"
+
int main(int, char**)
{
std::recursive_timed_mutex m;
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
std::recursive_timed_mutex m;
typedef std::chrono::system_clock Clock;
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
std::recursive_timed_mutex m;
typedef std::chrono::system_clock Clock;
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
std::recursive_timed_mutex m;
typedef std::chrono::steady_clock Clock;
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
std::recursive_timed_mutex m;
typedef std::chrono::steady_clock Clock;
#include <thread>
#include <cassert>
+#include "test_macros.h"
+
std::once_flag flg0;
long global = 0;
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
class G
{
int alive_;
#include <thread>
#include <cassert>
+#include "test_macros.h"
+
class G
{
int alive_;
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
class G
{
int alive_;
#include <thread>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::thread t;
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
class G
{
int alive_;
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
class G
{
int alive_;
#include <thread>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::thread::id id0;
#include <thread>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::thread::id id0;
#include <thread>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::thread::id id;
#include "poisoned_hash_helper.hpp"
+#include "test_macros.h"
+
int main(int, char**) {
test_library_hash_specializations_available();
{
#include <thread>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::thread::id id0;
#include <thread>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::thread::id id0;
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::thread::id id0 = std::this_thread::get_id();
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
class G
{
int alive_;
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
class G
{
int alive_;
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
class G
{
int alive_;
#include <thread>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
assert(std::thread::hardware_concurrency() > 0);
#include <thread>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::thread::id id = std::this_thread::get_id();
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::chrono::system_clock Clock;
#include <thread>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::this_thread::yield();
#include <scoped_allocator>
#include <cassert>
+#include "test_macros.h"
#include "allocators.h"
int main(int, char**)
#include <scoped_allocator>
#include <cassert>
+#include "test_macros.h"
#include "allocators.h"
int main(int, char**)
#include <scoped_allocator>
#include <cassert>
+#include "test_macros.h"
#include "allocators.h"
int main(int, char**)
#include <scoped_allocator>
#include <cassert>
+#include "test_macros.h"
#include "allocators.h"
int main(int, char**)
#include <scoped_allocator>
#include <cassert>
+#include "test_macros.h"
#include "allocators.h"
int main(int, char**)
#include <scoped_allocator>
#include <cassert>
+#include "test_macros.h"
#include "allocators.h"
int main(int, char**)
#include <scoped_allocator>
#include <cassert>
+#include "test_macros.h"
#include "allocators.h"
int main(int, char**)
#include <cassert>
#include <string>
+#include "test_macros.h"
#include "allocators.h"
struct B
#include "uses_alloc_types.hpp"
#include "controlled_allocators.hpp"
+#include "test_macros.h"
+
void test_no_inner_alloc()
{
#include "uses_alloc_types.hpp"
#include "controlled_allocators.hpp"
+#include "test_macros.h"
+
void test_no_inner_alloc()
{
#include "uses_alloc_types.hpp"
#include "controlled_allocators.hpp"
+#include "test_macros.h"
+
void test_no_inner_alloc()
{
#include "uses_alloc_types.hpp"
#include "controlled_allocators.hpp"
+#include "test_macros.h"
+
void test_no_inner_alloc()
{
#include "uses_alloc_types.hpp"
#include "controlled_allocators.hpp"
+#include "test_macros.h"
+
void test_no_inner_alloc()
{
#include "uses_alloc_types.hpp"
#include "controlled_allocators.hpp"
+#include "test_macros.h"
+
// - If uses_allocator_v<T, inner_allocator_type> is false and
// is_constructible_v<T, Args...> is true, calls
// OUTERMOST_ALLOC_TRAITS(*this)::construct(
#include <scoped_allocator>
#include <cassert>
+#include "test_macros.h"
#include "allocators.h"
int main(int, char**)
#include <cassert>
#include <string>
+#include "test_macros.h"
#include "allocators.h"
struct B
#include <scoped_allocator>
#include <cassert>
+#include "test_macros.h"
#include "allocators.h"
int main(int, char**)
#include <scoped_allocator>
#include <cassert>
+#include "test_macros.h"
#include "allocators.h"
int main(int, char**)
#include <scoped_allocator>
#include <cassert>
+#include "test_macros.h"
#include "allocators.h"
int main(int, char**)
#include <scoped_allocator>
#include <cassert>
+#include "test_macros.h"
#include "allocators.h"
int main(int, char**)
#include <cassert>
// #include <memory>
+
+#include "test_macros.h"
//
// template <class Alloc>
// struct allocator_traits
#include <scoped_allocator>
#include <type_traits>
+#include "test_macros.h"
#include "allocators.h"
int main(int, char**)
#include <scoped_allocator>
#include <type_traits>
+#include "test_macros.h"
#include "allocators.h"
#include "min_allocator.h"
#include <scoped_allocator>
#include <type_traits>
+#include "test_macros.h"
#include "allocators.h"
int main(int, char**)
#include <scoped_allocator>
#include <type_traits>
+#include "test_macros.h"
#include "allocators.h"
int main(int, char**)
#include <scoped_allocator>
#include <type_traits>
+#include "test_macros.h"
#include "allocators.h"
int main(int, char**)
#include <scoped_allocator>
#include <cassert>
+#include "test_macros.h"
#include "allocators.h"
int main(int, char**)
#include <scoped_allocator>
#include <cassert>
+#include "test_macros.h"
#include "allocators.h"
int main(int, char**)
#include <scoped_allocator>
#include <cassert>
+#include "test_macros.h"
#include "allocators.h"
int main(int, char**)
#include <scoped_allocator>
#include <type_traits>
+#include "test_macros.h"
#include "allocators.h"
int main(int, char**)
#include <any>
#include <cassert>
+#include "test_macros.h"
#include "any_helpers.h"
int main(int, char**)
#include <any>
#include <cassert>
+#include "test_macros.h"
#include "any_helpers.h"
using std::any;
#include <any>
#include <cassert>
+#include "test_macros.h"
#include "any_helpers.h"
int main(int, char**)
#include <any>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**) {
static_assert(!std::is_literal_type<std::any>::value, "");
#include <any>
#include <cassert>
+#include "test_macros.h"
+
using std::any;
using std::any_cast;
// from_chars_result from_chars(const char* first, const char* last,
// Integral& value, int base = 10)
+#include "test_macros.h"
#include "charconv_test_helpers.h"
template <typename T>
// to_chars_result to_chars(char* first, char* last, Integral value,
// int base = 10)
+#include "test_macros.h"
#include "charconv_test_helpers.h"
template <typename T>
#include <functional>
#include <string>
+#include "test_macros.h"
+
template <class T>
struct is_transparent
{
#include <functional>
#include <type_traits>
+#include "test_macros.h"
+
struct Fun
{
template<typename T, typename U>
#include <cmath>
#include <cassert>
+#include "test_macros.h"
+
float _pow(float a, float b)
{
return std::pow(a, b);
#include <functional>
+#include "test_macros.h"
+
struct DummyUnaryFunction
{
template <typename S>
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
template <class R, class F>
void
test(F f, R expected)
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
int count = 0;
// 1 arg, return void
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
int count = 0;
// 1 arg, return void
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
int count = 0;
template <class F>
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
struct power
{
template <typename T>
#include <functional>
+#include "test_macros.h"
+
template <class T>
void test() {
static_assert(!std::is_bind_expression<T>::value, "");
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::bit_not<int> F;
#include <functional>
#include <string>
+#include "test_macros.h"
+
template <class T>
struct is_transparent
{
#include <functional>
#include <string>
+#include "test_macros.h"
+
template <class T>
struct is_transparent
{
#include <utility> // for std::move
#include <cassert>
+#include "test_macros.h"
+
struct NonCopyable {
NonCopyable() {}
private:
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
double data_;
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
char test0() const {return 'a';}
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
char test0() const volatile {return 'a';}
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
char test0() volatile {return 'a';}
#include <functional>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::binary_function<int, short, bool> bf;
#include <functional>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::unary_function<int, bool> uf;
#include <functional>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <typename Iter1, typename Iter2>
#include <functional>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <typename T> struct MyHash {
#include <functional>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <typename T> struct MyHash {
#include <functional>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
struct count_equal
#include <functional>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <typename Iter1, typename Iter2>
#include <functional>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <typename T> struct MyHash {
#include <functional>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <typename T> struct MyHash {
#include <functional>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
struct count_equal
#include <functional>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
template <typename Iter1, typename Iter2>
#include <functional>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
struct count_equal
#include <functional>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::exception, std::bad_function_call>::value), "");
#include <functional>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
std::bad_function_call ex;
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
int g(int) {return 0;}
int main(int, char**)
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
struct X{
typedef std::function<void(X&)> callback_type;
virtual ~X() {}
#include <functional>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <functional>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
#include "test_allocator.h"
#include "count_new.hpp"
#include <functional>
#include <cassert>
+#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**)
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::function<int(int)> f;
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::function<int(int)> f(nullptr);
#include "count_new.hpp"
+#include "test_macros.h"
+
class A
{
int data_[10];
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
int count = 0;
#include "count_new.hpp"
+#include "test_macros.h"
+
class A {
int data_[10];
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
int g(int) {return 0;}
int main(int, char**)
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
class A
{
int data_[10];
#include <typeinfo>
#include <cassert>
+#include "test_macros.h"
+
class A
{
int data_[10];
#include <functional>
#include <type_traits>
+#include "test_macros.h"
+
template <typename T>
class has_argument_type
#include <functional>
#include <string>
+#include "test_macros.h"
+
template <class T>
struct is_transparent
{
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::binary_negate<std::logical_and<int> > F;
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::logical_not<int> F;
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::logical_and<int> F;
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::unary_negate<std::logical_not<int> > F;
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
class functor1
{
};
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
class functor1
{
};
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
class functor1
{
};
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
struct Foo;
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
class functor1
{
};
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
struct Foo;
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int i = 0;
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
const int i = 0;
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
struct Foo;
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int i = 0;
#include "counting_predicates.hpp"
+#include "test_macros.h"
+
bool is5 ( int i ) { return i == 5; }
template <typename T>
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
int count = 0;
// 1 arg, return void
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
// 0 args, return int
int count = 0;
#include <functional>
#include <cassert>
+#include "test_macros.h"
+
// 0 args, return void
int count = 0;
#include <functional>
#include <type_traits>
+#include "test_macros.h"
+
class C {};
int main(int, char**)
#include <functional>
#include <type_traits>
+#include "test_macros.h"
+
template <typename T, typename Result>
void check() {
#include <functional>
#include <type_traits>
+#include "test_macros.h"
+
template <typename T, typename Expected>
void check_equal() {
#include <functional>
#include <type_traits>
+#include "test_macros.h"
+
template <class Arg, class Result>
struct my_unary_function
{ // std::unary_function was removed in C++17
#include "poisoned_hash_helper.hpp"
+#include "test_macros.h"
+
int main(int, char**) {
test_library_hash_specializations_available();
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
template <typename AtContainer, typename T, T... I>
auto extract ( const AtContainer &t, const std::integer_sequence<T, I...> )
-> decltype ( std::make_tuple ( std::get<I>(t)... ))
#include <cstddef>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
// Make a few of sequences
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert(std::is_same<std::make_integer_sequence<int, 0>, std::integer_sequence<int>>::value, "");
#define _LIBCPP_TESTING_FALLBACK_MAKE_INTEGER_SEQUENCE
#include "make_integer_seq.pass.cpp"
+
+#include "test_macros.h"
#include <memory>
+#include "test_macros.h"
+
void test(std::allocator_arg_t) {}
int main(int, char**)
#include <cstdint>
#include <cassert>
+#include "test_macros.h"
#include "incomplete_type_helper.h"
template <class T>
#include <cstdint>
#include <cassert>
+#include "test_macros.h"
#include "incomplete_type_helper.h"
int called = 0;
#include <memory>
#include <type_traits>
+#include "test_macros.h"
+
template <class T>
struct A
{
#include <memory>
#include <type_traits>
+#include "test_macros.h"
+
template <class T>
struct A
{
#include <memory>
#include <type_traits>
+#include "test_macros.h"
+
template <class T>
struct A
{
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::allocator<int> a1;
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
void test_address()
{
#include <cstddef>
#include <cassert>
+#include "test_macros.h"
+
int new_called = 0;
int main(int, char**)
#include <cassert>
// #include <memory>
+
+#include "test_macros.h"
//
// template <class Alloc>
// struct allocator_traits
#include <memory>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_same<std::allocator<void>::pointer, void*>::value), "");
#include <memory>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_same<std::pointer_traits<double*>::difference_type, std::ptrdiff_t>::value), "");
#include <memory>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_same<std::pointer_traits<const short*>::element_type, const short>::value), "");
#include <memory>
#include <type_traits>
+#include "test_macros.h"
+
struct A
{
typedef short element_type;
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
template <class T>
struct A
{
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
const unsigned N = 20;
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
void operator&() const {}
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
struct Pointer {
constexpr Pointer(void* v) : value(v) {}
void* value;
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
struct Counted {
static int count;
static void reset() { count = 0; }
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
struct alignas(32) A {
int field;
};
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::pair<int*, std::ptrdiff_t> ip = std::get_temporary_buffer<int>(5);
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::unique_ptr<int> p(new int(3));
#include <memory>
+#include "test_macros.h"
+
int main(int, char**)
{
char* p = new char[10];
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
int* p = new int;
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
void test_pr26961() {
std::pointer_safety d;
#include "poisoned_hash_helper.hpp"
+#include "test_macros.h"
+
int main(int, char**) {
test_library_hash_specializations_available();
#if TEST_STD_VER >= 11
#include "poisoned_hash_helper.hpp"
+#include "test_macros.h"
+
struct A {};
#endif
#include <memory>
#include <cassert>
+#include "test_macros.h"
#include "deleter_types.h"
struct A
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
struct B
{
static int count;
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
struct B
{
static int count;
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
struct B
{
static int count;
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
struct B
{
static int count;
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
struct B
{
static int count;
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
struct B
{
static int count;
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
struct B
{
static int count;
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
struct B
{
static int count;
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
struct B
{
static int count;
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
void do_nothing(int*) {}
int main(int, char**)
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
void do_nothing(int*) {}
int main(int, char**)
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
void do_nothing(int*) {}
int main(int, char**)
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::shared_ptr<int> p;
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::shared_ptr<int> p(nullptr);
#include <memory>
#include <cassert>
+#include "test_macros.h"
#include "deleter_types.h"
struct A
#include <memory>
#include <cassert>
+#include "test_macros.h"
#include "deleter_types.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <memory>
#include <cassert>
+#include "test_macros.h"
#include "deleter_types.h"
#include "test_allocator.h"
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
static int count;
#include <memory>
#include <cassert>
+#include "test_macros.h"
#include "deleter_types.h"
struct A
#include <memory>
#include <cassert>
+#include "test_macros.h"
#include "deleter_types.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <memory>
#include <cassert>
+#include "test_macros.h"
#include "deleter_types.h"
#include "test_allocator.h"
#include <cstdlib>
#include "count_new.hpp"
+#include "test_macros.h"
#include "deleter_types.h"
struct A
#include "count_new.hpp"
+#include "test_macros.h"
+
struct A
{
static int count;
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
static int count;
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
struct B
{
static int count;
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
struct B
{
static int count;
#include <new>
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <new>
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
#include "test_allocator.h"
#include "min_allocator.h"
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
template <typename T>
void test(const T &t0)
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::shared_ptr<int> p(new int(3));
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
struct B
{
static int count;
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
struct B
{
static int count;
#include <memory>
#include <cassert>
+#include "test_macros.h"
#include "deleter_types.h"
struct B
#include <memory>
#include <cassert>
+#include "test_macros.h"
#include "deleter_types.h"
#include "test_allocator.h"
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
static int count;
#include <utility>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
const std::shared_ptr<std::pair<int, int> > p(new std::pair<int, int>(3, 4));
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
const std::shared_ptr<int> p(new int(32));
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
const std::shared_ptr<int> p(new int(32));
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
static int count;
#include <memory>
+#include "test_macros.h"
+
struct A; // purposefully incomplete
int main(int, char**)
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
struct B
{
static int count;
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
struct B
{
static int count;
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
struct B
{
static int count;
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
struct A;
int main(int, char**)
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
struct B
{
static int count;
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
struct B
{
static int count;
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
static int count;
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
static int count;
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
static int count;
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
static int count;
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
static int count;
#include <cassert>
#include <cstring>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_base_of<std::exception, std::bad_weak_ptr>::value), "");
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
struct True { static constexpr bool value = true; };
struct False { static constexpr bool value = false; };
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
struct True { static constexpr bool value = true; };
struct False { static constexpr bool value = false; };
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
struct True { static constexpr bool value = true; };
struct False { static constexpr bool value = false; };
#define _LIBCPP_USE_IS_CONVERTIBLE_FALLBACK
#include "is_convertible.pass.cpp"
+#include "test_macros.h"
+
#include <type_traits>
+#include "test_macros.h"
+
struct A {};
struct B {
public:
#include <type_traits>
#include <cstddef> // for std::nullptr_t
+#include "test_macros.h"
+
template <class T>
void test_nullptr_imp()
{
#include <type_traits>
+#include "test_macros.h"
+
template <class T>
void test_array_imp()
{
#include <type_traits>
+#include "test_macros.h"
+
template <class T>
void test_class_imp()
{
#include <type_traits>
+#include "test_macros.h"
+
template <class T>
void test_enum_imp()
{
#include <type_traits>
+#include "test_macros.h"
+
template <class T>
void test_floating_point_imp()
{
#include <type_traits>
+#include "test_macros.h"
+
template <class T>
void test_function_imp()
{
#include <type_traits>
+#include "test_macros.h"
+
template <class T>
void test_integral_imp()
{
#include <type_traits>
+#include "test_macros.h"
+
template <class T, bool B>
void test_array_imp()
{
#include <type_traits>
+#include "test_macros.h"
+
template <class T, bool B>
void test_array_imp()
{
#include <type_traits>
+#include "test_macros.h"
+
template <class T>
void test_lvalue_ref()
{
#include <type_traits>
+#include "test_macros.h"
+
template <class T>
void test_member_function_pointer_imp()
{
#include <type_traits>
+#include "test_macros.h"
+
template <class T>
void test_member_object_pointer_imp()
{
#include <type_traits>
+#include "test_macros.h"
+
template <class T>
void test_pointer_imp()
{
#include <type_traits>
+#include "test_macros.h"
+
template <class T>
void test_rvalue_ref()
{
#include <type_traits>
+#include "test_macros.h"
+
template <class T>
void test_union_imp()
{
#include <type_traits>
+#include "test_macros.h"
+
template <class T>
void test_void_imp()
{
#include <optional>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
using std::bad_optional_access;
#include <optional>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
using std::bad_optional_access;
#include <optional>
+#include "test_macros.h"
+
using std::optional;
struct X {
#include <optional>
+#include "test_macros.h"
+
using std::optional;
struct X {
#include <optional>
+#include "test_macros.h"
+
using std::optional;
struct X {
#include <optional>
+#include "test_macros.h"
+
using std::optional;
struct X {
#include <optional>
+#include "test_macros.h"
+
using std::optional;
struct X {
#include <optional>
+#include "test_macros.h"
+
using std::optional;
struct X {
#include "poisoned_hash_helper.hpp"
+#include "test_macros.h"
+
int main(int, char**) {
test_library_hash_specializations_available();
{
#include "poisoned_hash_helper.hpp"
+#include "test_macros.h"
+
struct A {};
struct B {};
#include <optional>
+#include "test_macros.h"
+
int main(int, char**)
{
using std::optional;
#include <optional>
+#include "test_macros.h"
+
int main(int, char**)
{
using std::optional;
#include <optional>
+#include "test_macros.h"
+
int main(int, char**)
{
using std::optional;
#include <optional>
+#include "test_macros.h"
+
int main(int, char**)
{
using std::optional;
#include <optional>
+#include "test_macros.h"
+
int main(int, char**)
{
using std::optional;
#include <optional>
+#include "test_macros.h"
+
int main(int, char**)
{
using std::optional;
#include <optional>
#include <type_traits>
+#include "test_macros.h"
+
using std::nullopt_t;
using std::nullopt;
#include <optional>
#include <cassert>
+#include "test_macros.h"
+
struct A {};
int main(int, char**)
#include "archetypes.hpp"
+#include "test_macros.h"
+
using std::optional;
using std::nullopt_t;
using std::nullopt;
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
using std::optional;
struct PODType {
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
using std::optional;
struct X
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
using std::optional;
struct Y
#include "archetypes.hpp"
+#include "test_macros.h"
+
template <class T>
struct SpecialMemberTest {
#include "archetypes.hpp"
+#include "test_macros.h"
+
constexpr bool implies(bool p, bool q) {
return !p || q;
#include <optional>
#include <type_traits>
+#include "test_macros.h"
+
using std::optional;
template <class Opt, class T>
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
using std::optional;
struct X {
#include <optional>
+#include "test_macros.h"
+
using std::optional;
struct X {
#include <optional>
+#include "test_macros.h"
+
using std::optional;
struct X {
#include <optional>
+#include "test_macros.h"
+
using std::optional;
struct X {
#include <optional>
+#include "test_macros.h"
+
using std::optional;
struct X {
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
using std::optional;
struct X {
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
using std::optional;
#include <optional>
+#include "test_macros.h"
+
int main(int, char**)
{
using std::optional;
#include <ratio>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <ratio>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <ratio>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <ratio>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <ratio>
+#include "test_macros.h"
+
template <long long N, long long D, long long eN, long long eD>
void test()
{
#include <ratio>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert(std::atto::num == 1 && std::atto::den == 1000000000000000000ULL, "");
#include <utility>
#include <cassert>
+#include "test_macros.h"
#include "deleter_types.h"
#include "unique_ptr_test_helper.h"
#include <utility>
#include <cassert>
+#include "test_macros.h"
#include "unique_ptr_test_helper.h"
template <class APtr, class BPtr>
#include <utility>
#include <cassert>
+#include "test_macros.h"
#include "deleter_types.h"
#include "unique_ptr_test_helper.h"
#include <memory>
#include <cassert>
+#include "test_macros.h"
#include "unique_ptr_test_helper.h"
// test assignment from null
#include <memory>
#include <cassert>
+#include "test_macros.h"
#include "unique_ptr_test_helper.h"
// test assignment from null
#include <memory>
#include <cassert>
+#include "test_macros.h"
#include "deleter_types.h"
#include "unique_ptr_test_helper.h"
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
class Deleter {
int state_;
#include <memory>
#include <cassert>
+#include "test_macros.h"
#include "unique_ptr_test_helper.h"
int main(int, char**) {
#include <memory>
+#include "test_macros.h"
+
struct A {
std::unique_ptr<A> ptr_;
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**) {
std::unique_ptr<int> p(new int(3));
assert(*p == 3);
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
struct A {
int i_;
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
class A {
int state_;
static int next_;
#include <string>
#include <cassert>
+#include "test_macros.h"
+
// The only way to create an unique_ptr<T[]> is to default construct them.
class foo {
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
static int count;
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
static int count;
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::default_delete<int[]> d1;
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
static int count;
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
void do_nothing(int*) {}
int main(int, char**)
#include <memory>
#include <cassert>
+#include "test_macros.h"
#include "deleter_types.h"
struct A
#include <memory>
#include <cassert>
+#include "test_macros.h"
#include "deleter_types.h"
struct A
#include "poisoned_hash_helper.hpp"
+#include "test_macros.h"
+
int main(int, char**) {
test_library_hash_specializations_available();
{
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
template <std::size_t N>
void test_all()
{
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
template <std::size_t N>
void test_any()
{
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
template <std::size_t N>
void test_none()
{
#include <bitset>
#include <cassert>
+#include "test_macros.h"
+
template <std::size_t N>
void test_size()
{
#include <climits>
#include <cassert>
+#include "test_macros.h"
+
template <std::size_t N>
void test_to_ullong()
{
#include <climits>
#include <cassert>
+#include "test_macros.h"
+
template <std::size_t N>
void test_to_ulong()
{
#include <sstream>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::ostringstream os;
#include <bitset>
+#include "test_macros.h"
+
template <class> void test_typedef() {}
int main(int, char**)
#include <type_traits>
#include <limits>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::chrono::days D;
#include <type_traits>
#include <limits>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::chrono::hours D;
#include <type_traits>
#include <limits>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::chrono::microseconds D;
#include <type_traits>
#include <limits>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::chrono::milliseconds D;
#include <type_traits>
#include <limits>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::chrono::minutes D;
#include <type_traits>
#include <limits>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::chrono::months D;
#include <type_traits>
#include <limits>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::chrono::nanoseconds D;
#include <type_traits>
#include <limits>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::chrono::seconds D;
#include <chrono>
+#include "test_macros.h"
+
template <class T>
void test(const T &) {}
#include <chrono>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert(std::is_signed<std::chrono::file_clock::rep>::value, "");
#include <chrono>
+#include "test_macros.h"
+
template <class T>
void test(const T &) {}
#include <chrono>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::chrono::high_resolution_clock C;
#include <chrono>
+#include "test_macros.h"
+
template <class T>
void test(const T &) {}
#include <chrono>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::chrono::steady_clock C;
#include <chrono>
+#include "test_macros.h"
+
template <class T>
void test(const T &) {}
#include <chrono>
#include <ctime>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::chrono::system_clock C;
#include <chrono>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::chrono::system_clock C;
#include <chrono>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
assert(std::chrono::system_clock::duration::min() <
#include <chrono>
#include <ctime>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::chrono::system_clock C;
#include <chrono>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_same<std::chrono::duration<int, std::ratio<1> >,
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
template <class Duration>
void
test(const Duration& f, const Duration& d)
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
template <class ToDuration, class FromDuration>
void
test(const FromDuration& f, const ToDuration& d)
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
template <class ToDuration, class FromDuration>
void
test(const FromDuration& f, const ToDuration& d)
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
template <class ToDuration, class FromDuration>
void
test(const FromDuration& f, const ToDuration& d)
#include <chrono>
#include <cassert>
+#include "test_macros.h"
+
bool called = false;
void f(std::chrono::milliseconds);
#include <chrono>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
using namespace std::chrono;
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
using namespace std::literals;
#include <chrono>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::chrono::duration<long, std::ratio<3, 2> > D;
#include <chrono>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert((std::is_same<std::chrono::system_clock::duration,
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
template <class FromDuration, class ToDuration>
void
test(const FromDuration& df, const ToDuration& d)
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
template <class FromDuration, class ToDuration>
void
test(const FromDuration& df, const ToDuration& d)
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
template <class FromDuration, class ToDuration>
void
test(const FromDuration& df, const ToDuration& d)
#include <chrono>
+#include "test_macros.h"
+
template <class D1, class D2, class De>
void
test()
#include <chrono>
+#include "test_macros.h"
+
template <class D1, class D2, class De>
void
test()
#include <type_traits>
#include <limits>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::chrono::weeks D;
#include <type_traits>
#include <limits>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::chrono::years D;
#include <tuple>
#include <memory>
+#include "test_macros.h"
+
int main(int, char**) {
{
std::tuple<std::unique_ptr<char>> up;
#include <tuple>
#include <functional>
+#include "test_macros.h"
+
struct X
{
X() {}
// std::array is explicitly allowed to be initialized with A a = { init-list };.
// Disable the missing braces warning for this reason.
+#include "test_macros.h"
#include "disable_missing_braces_warning.h"
int count = 0;
#include <utility>
#include <cassert>
+#include "test_macros.h"
+
////////////////////////////////////////////////////////////////////////////////
template <class T, std::size_t Dummy = 0>
struct always_imp
#include <utility>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <string>
#include <cassert>
+#include "test_macros.h"
+
struct B
{
int id_;
#include <utility>
#include <cassert>
+#include "test_macros.h"
+
struct B
{
int id_;
#include <utility>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
struct NonAssignable {
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
struct B
{
int id_;
#include <array>
#include <tuple>
+#include "test_macros.h"
+
// Use 1256 to try and blow the template instantiation depth for all compilers.
typedef std::array<char, 1256> array_t;
typedef std::tuple<array_t> tuple_t;
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
template <class Tp>
using uncvref_t = typename std::remove_cv<typename std::remove_reference<Tp>::type>::type;
#include <memory>
#include <type_traits>
+#include "test_macros.h"
+
struct UnconstrainedCtor {
int value_;
#include <tuple>
#include <cassert>
+#include "test_macros.h"
+
struct IncompleteType;
extern IncompleteType inc1;
extern IncompleteType inc2;
#include <tuple>
#include <cassert>
+#include "test_macros.h"
+
int count = 0;
struct Explicit {
#include <tuple>
#include <cassert>
+#include "test_macros.h"
#include "DefaultOnly.h"
#include "allocators.h"
#include "../alloc_first.h"
#include <tuple>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "allocators.h"
#include "../alloc_first.h"
#include <memory>
#include <cassert>
+#include "test_macros.h"
#include "allocators.h"
#include "../alloc_first.h"
#include "../alloc_last.h"
#include <utility>
#include <cassert>
+#include "test_macros.h"
#include "allocators.h"
#include "../alloc_first.h"
#include "../alloc_last.h"
#include <memory>
#include <cassert>
+#include "test_macros.h"
#include "allocators.h"
#include "../alloc_first.h"
#include "../alloc_last.h"
#include <memory>
#include <cassert>
+#include "test_macros.h"
#include "allocators.h"
#include "../alloc_first.h"
#include "../alloc_last.h"
#include <tuple>
#include <cassert>
+#include "test_macros.h"
#include "allocators.h"
#include "../alloc_first.h"
#include "../alloc_last.h"
#include <tuple>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
#include "allocators.h"
#include "../alloc_first.h"
#include <memory>
#include <cassert>
+#include "test_macros.h"
#include "allocators.h"
#include "../alloc_first.h"
#include "../alloc_last.h"
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
struct Explicit {
int value;
explicit Explicit(int x) : value(x) {}
#include <cassert>
#include <type_traits>
+#include "test_macros.h"
#include "DefaultOnly.h"
struct NoDefault {
#include <cassert>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
static_assert(std::is_trivially_destructible<
#include <utility>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
struct ConstructsWithTupleLeaf
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
struct B
{
int id_;
#include <utility>
#include <cassert>
+#include "test_macros.h"
+
template <class ConstructFrom>
struct ConstructibleFromT {
ConstructibleFromT() = default;
#include <array>
#include <tuple>
+#include "test_macros.h"
+
// Use 1256 to try and blow the template instantiation depth for all compilers.
typedef std::array<char, 1256> array_t;
typedef std::tuple<array_t> tuple_t;
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::complex<float> cf;
#include <array>
#include <type_traits>
+#include "test_macros.h"
+
template <class T, std::size_t N, class U, size_t idx>
void test()
{
#include <utility>
#include <type_traits>
+#include "test_macros.h"
+
template <class T, std::size_t N, class U, size_t idx>
void test()
{
#include <tuple>
#include <type_traits>
+#include "test_macros.h"
+
template <class T, std::size_t N>
void test()
{
#include <array>
#include <type_traits>
+#include "test_macros.h"
+
template <class T, size_t Size = sizeof(std::tuple_size<T>)>
constexpr bool is_complete(int) { static_assert(Size > 0, ""); return true; }
template <class> constexpr bool is_complete(long) { return false; }
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
struct S { int x; };
void test_decomp_user_type() {
#include <utility>
#include <array>
+#include "test_macros.h"
+
template <class Tuple, int Expect>
void test()
{
#include <tuple>
#include <type_traits>
+#include "test_macros.h"
+
template <class T, class = decltype(std::tuple_size<T>::value)>
constexpr bool has_value(int) { return true; }
template <class> constexpr bool has_value(long) { return false; }
#include <tuple>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
int main(int, char**)
#include <tuple>
#include <cassert>
+#include "test_macros.h"
#include "MoveOnly.h"
int main(int, char**)
#include <tuple>
#include <type_traits>
+#include "test_macros.h"
+
struct A {};
int main(int, char**)
#include "poisoned_hash_helper.hpp"
+#include "test_macros.h"
+
int main(int, char**) {
test_library_hash_specializations_available();
#include <type_traits>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::hash<std::type_index> H;
#include <typeindex>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::type_info const & info = typeid(int);
#include <typeindex>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::type_index t1 = typeid(int);
#include <typeindex>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
const std::type_info& ti = typeid(int);
#include <typeindex>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::type_index t1 = typeid(int);
#include <string>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
const std::type_info& ti = typeid(int);
#include <typeindex>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::type_index t1(typeid(int));
#include <typeindex>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
std::type_index t1(typeid(int));
#include <utility>
#include <cassert>
+#include "test_macros.h"
+
struct S {int i;};
bool operator==(const S& x, const S& y) { return x.i == y.i; }
bool operator==(const volatile S& x, const volatile S& y) { return x.i == y.i; }
#include <utility>
#include <cassert>
+#include "test_macros.h"
+
struct A
{
int data_;
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::complex<float> cf;
#include <utility>
+#include "test_macros.h"
+
template <class T1, class T2>
void test()
{
#include <utility>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <tuple>
#include <cassert>
+#include "test_macros.h"
+
class A
{
int i_;
#include "archetypes.hpp"
#include "test_convertible.hpp"
+
+#include "test_macros.h"
using namespace ImplicitTypes; // Get implicitly archetypes
template <class T1, class T1Arg,
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
struct NonAssignable {
NonAssignable& operator=(NonAssignable const&) = delete;
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
struct NonAssignable {
NonAssignable() {}
private:
#include <memory>
#include <cassert>
+#include "test_macros.h"
+
struct NonAssignable {
NonAssignable& operator=(NonAssignable const&) = delete;
#include <cassert>
#include <archetypes.hpp>
+#include "test_macros.h"
+
struct Base
{
virtual ~Base() {}
#include "archetypes.hpp"
#include "test_convertible.hpp"
+
+#include "test_macros.h"
using namespace ImplicitTypes; // Get implicitly archetypes
struct ExplicitT {
#include <utility>
#include <cassert>
+#include "test_macros.h"
+
class A
{
int data_;
#include "archetypes.hpp"
#include "test_convertible.hpp"
+
+#include "test_macros.h"
using namespace ImplicitTypes; // Get implicitly archetypes
template <class T1, class U1,
#include <utility>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <tuple>
#include <utility>
+#include "test_macros.h"
+
int main(int, char**)
{
#include "archetypes.hpp"
#include "test_convertible.hpp"
+
+#include "test_macros.h"
using namespace ImplicitTypes; // Get implicitly archetypes
template <class T1, class U1,
#include <tuple>
#include "archetypes.hpp"
+
+#include "test_macros.h"
using namespace ImplicitTypes; // Get implicitly archetypes
namespace ConstructorTest {
#include <utility>
#include <cassert>
+#include "test_macros.h"
+
struct S {
int i;
S() : i(0) {}
#include <utility>
#include <type_traits>
+#include "test_macros.h"
+
int main(int, char**)
{
typedef std::pair<float, short*> P;
#include <utility>
#include <cassert>
+#include "test_macros.h"
+
int main(int, char**)
{
{
#include <utility>
+#include "test_macros.h"
+
int main(int, char**)
{
std::initializer_list<int> x;
#include <type_traits>
#include <variant>
+#include "test_macros.h"
+
int main(int, char**) {
static_assert(std::is_base_of<std::exception, std::bad_variant_access>::value,
"");
#include "poisoned_hash_helper.hpp"
+#include "test_macros.h"
+
int main(int, char**) {
test_library_hash_specializations_available();
#include <type_traits>
#include <variant>
+#include "test_macros.h"
+
template <class V, size_t E> void test() {
static_assert(std::variant_size<V>::value == E, "");
static_assert(std::variant_size<const V>::value == E, "");
#include <type_traits>
#include <variant>
+#include "test_macros.h"
+
int main(int, char**) {
using M = std::monostate;
static_assert(std::is_trivially_default_constructible<M>::value, "");
#include <variant>
+#include "test_macros.h"
+
int main(int, char**) {
static_assert(std::variant_npos == static_cast<std::size_t>(-1), "");
#include "test_convertible.hpp"
+#include "test_macros.h"
+
struct ImplicitDefault {
ImplicitDefault() {}
};
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
+#include "test_macros.h"
#include "demangle.h"
#include <typeinfo>
#include <cassert>
#include "poisoned_hash_helper.hpp"
+#include "test_macros.h"
+
template <class T, size_t = sizeof(T)>
constexpr bool is_complete_imp(int) { return true; }
template <class> constexpr bool is_complete_imp(long) { return false; }
#include <type_traits>
+#include "test_macros.h"
#include "test_workarounds.h"
struct S {
#include <type_traits>
+#include "test_macros.h"
#include "test_workarounds.h"
struct X {
projects / platform / upstream / llvm.git / commitdiff